func TestNewBuildEnvVars(t *testing.T) {
dockerSearcher := app.DockerRegistrySearcher{
Client: dockerregistry.NewClient(),
}
tests := []struct {
name string
config *AppConfig
expected []kapi.EnvVar
expectedErr error
}{
{
name: "explicit environment variables for buildConfig and deploymentConfig",
config: &AppConfig{
AddEnvironmentToBuild: true,
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
DockerImages: util.StringList([]string{"openshift/ruby-20-centos7", "openshift/mongodb-24-centos7"}),
OutputDocker: true,
Environment: util.StringList([]string{"BUILD_ENV_1=env_value_1", "BUILD_ENV_2=env_value_2"}),
dockerSearcher: dockerSearcher,
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: []kapi.EnvVar{
{Name: "BUILD_ENV_1", Value: "env_value_1"},
{Name: "BUILD_ENV_2", Value: "env_value_2"},
},
expectedErr: nil,
},
}
for _, test := range tests {
test.config.refBuilder = &app.ReferenceBuilder{}
test.config.Out, test.config.ErrOut = os.Stdout, os.Stderr
res, err := test.config.RunBuilds()
if err != test.expectedErr {
t.Errorf("%s: Error mismatch! Expected %v, got %v", test.name, test.expectedErr, err)
continue
}
got := []kapi.EnvVar{}
for _, obj := range res.List.Items {
switch tp := obj.(type) {
case *buildapi.BuildConfig:
got = tp.Spec.Strategy.SourceStrategy.Env
break
}
}
if !reflect.DeepEqual(test.expected, got) {
t.Errorf("%s: unexpected output. Expected: %#v, Got: %#v", test.name, test.expected, got)
continue
}
}
}
func (o CreateNodeConfigOptions) MakeClientCert(clientCertFile, clientKeyFile string) error {
if o.IsCreateClientCertificate() {
createNodeClientCert := CreateClientCertOptions{
SignerCertOptions: o.SignerCertOptions,
CertFile: clientCertFile,
KeyFile: clientKeyFile,
User: "******" + o.NodeName,
Groups: util.StringList([]string{bootstrappolicy.NodesGroup}),
Output: o.Output,
}
if err := createNodeClientCert.Validate(nil); err != nil {
return err
}
if _, err := createNodeClientCert.CreateClientCert(); err != nil {
return err
}
} else {
if err := CopyFile(o.ClientCertFile, clientCertFile, 0644); err != nil {
return err
}
if err := CopyFile(o.ClientKeyFile, clientKeyFile, 0600); err != nil {
return err
}
}
return nil
}
// ensureCORSAllowedOrigins takes a string list of origins and attempts to covert them to CORS origin
// regexes, or exits if it cannot.
func (c *MasterConfig) ensureCORSAllowedOrigins() []*regexp.Regexp {
if len(c.Options.CORSAllowedOrigins) == 0 {
return []*regexp.Regexp{}
}
allowedOriginRegexps, err := util.CompileRegexps(util.StringList(c.Options.CORSAllowedOrigins))
if err != nil {
glog.Fatalf("Invalid --cors-allowed-origins: %v", err)
}
return allowedOriginRegexps
}
func TestSecretTypeDiscovered(t *testing.T) {
options := CreateSecretOptions{
Name: "any",
Sources: util.StringList([]string{"./bsFixtures/leadingdot/.dockercfg"}),
Stderr: ioutil.Discard,
}
secret, err := options.BundleSecret()
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if secret.Type != kapi.SecretTypeDockercfg {
t.Errorf("expected %v, got %v", kapi.SecretTypeDockercfg, secret.Type)
}
}
func (o CreateMasterCertsOptions) createClientCert(clientCertInfo ClientCertInfo, getSignerCertOptions *SignerCertOptions) error {
clientCertOptions := CreateClientCertOptions{
SignerCertOptions: getSignerCertOptions,
CertFile: clientCertInfo.CertLocation.CertFile,
KeyFile: clientCertInfo.CertLocation.KeyFile,
User: clientCertInfo.User,
Groups: util.StringList(clientCertInfo.Groups.List()),
Overwrite: o.Overwrite,
Output: o.Output,
}
if _, err := clientCertOptions.CreateClientCert(); err != nil {
return err
}
return nil
}
func TestValidate(t *testing.T) {
tests := map[string]struct {
cfg AppConfig
componentValues []string
sourceRepoLocations []string
env map[string]string
parms map[string]string
}{
"components": {
cfg: AppConfig{
Components: util.StringList([]string{"one", "two", "three/four"}),
},
componentValues: []string{"one", "two", "three/four"},
sourceRepoLocations: []string{},
env: map[string]string{},
parms: map[string]string{},
},
"envs": {
cfg: AppConfig{
Environment: util.StringList([]string{"one=first", "two=second", "three=third"}),
},
componentValues: []string{},
sourceRepoLocations: []string{},
env: map[string]string{"one": "first", "two": "second", "three": "third"},
parms: map[string]string{},
},
"component+source": {
cfg: AppConfig{
Components: util.StringList([]string{"one~https://server/repo.git"}),
},
componentValues: []string{"one"},
sourceRepoLocations: []string{"https://server/repo.git"},
env: map[string]string{},
parms: map[string]string{},
},
"components+source": {
cfg: AppConfig{
Components: util.StringList([]string{"mysql+ruby~git://github.com/namespace/repo.git"}),
},
componentValues: []string{"mysql", "ruby"},
sourceRepoLocations: []string{"git://github.com/namespace/repo.git"},
env: map[string]string{},
parms: map[string]string{},
},
"components+parms": {
cfg: AppConfig{
Components: util.StringList([]string{"ruby-helloworld-sample"}),
TemplateParameters: util.StringList([]string{"one=first", "two=second"}),
},
componentValues: []string{"ruby-helloworld-sample"},
sourceRepoLocations: []string{},
env: map[string]string{},
parms: map[string]string{
"one": "first",
"two": "second",
},
},
}
for n, c := range tests {
c.cfg.refBuilder = &app.ReferenceBuilder{}
cr, _, env, parms, err := c.cfg.validate()
if err != nil {
t.Errorf("%s: Unexpected error: %v", n, err)
}
compValues := []string{}
for _, r := range cr {
compValues = append(compValues, r.Input().Value)
}
if !reflect.DeepEqual(c.componentValues, compValues) {
t.Errorf("%s: Component values don't match. Expected: %v, Got: %v", n, c.componentValues, compValues)
}
if len(env) != len(c.env) {
t.Errorf("%s: Environment variables don't match. Expected: %v, Got: %v", n, c.env, env)
}
for e, v := range env {
if c.env[e] != v {
t.Errorf("%s: Environment variables don't match. Expected: %v, Got: %v", n, c.env, env)
break
}
}
if len(parms) != len(c.parms) {
t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)
}
for p, v := range parms {
if c.parms[p] != v {
t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)
break
}
}
}
}
func TestRunBuilds(t *testing.T) {
dockerSearcher := app.DockerRegistrySearcher{
Client: dockerregistry.NewClient(),
}
tests := []struct {
name string
config *AppConfig
expected map[string][]string
expectedErr func(error) bool
}{
{
name: "successful ruby app generation",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
DockerImages: util.StringList([]string{"openshift/ruby-20-centos7", "openshift/mongodb-24-centos7"}),
OutputDocker: true,
dockerSearcher: dockerSearcher,
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationSearcher: &app.ImageStreamByAnnotationSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"buildConfig": {"ruby-hello-world"},
"imageStream": {"ruby-20-centos7"},
},
},
{
name: "successful build from dockerfile",
config: &AppConfig{
Dockerfile: "FROM openshift/origin-base\nUSER foo",
dockerSearcher: dockerSearcher,
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationSearcher: &app.ImageStreamByAnnotationSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"buildConfig": {"origin-base"},
"imageStream": {"origin-base"},
},
},
{
name: "unsuccessful build from dockerfile due to strategy conflict",
config: &AppConfig{
Dockerfile: "FROM openshift/origin-base\nUSER foo",
Strategy: "source",
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expectedErr: func(err error) bool {
return err.Error() == "when directly referencing a Dockerfile, the strategy must must be 'docker'"
},
},
{
name: "unsuccessful build from dockerfile due to missing FROM instruction",
config: &AppConfig{
Dockerfile: "USER foo",
Strategy: "docker",
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expectedErr: func(err error) bool {
return err.Error() == "the Dockerfile in the repository \"\" has no FROM instruction"
},
},
}
for _, test := range tests {
test.config.refBuilder = &app.ReferenceBuilder{}
test.config.Out, test.config.ErrOut = os.Stdout, os.Stderr
res, err := test.config.RunBuilds()
if (test.expectedErr == nil && err != nil) || (test.expectedErr != nil && !test.expectedErr(err)) {
t.Errorf("%s: unexpected error: %v", test.name, err)
continue
}
if err != nil {
continue
}
got := map[string][]string{}
for _, obj := range res.List.Items {
switch tp := obj.(type) {
case *buildapi.BuildConfig:
got["buildConfig"] = append(got["buildConfig"], tp.Name)
case *imageapi.ImageStream:
got["imageStream"] = append(got["imageStream"], tp.Name)
}
}
if len(test.expected) != len(got) {
t.Errorf("%s: Resource kind size mismatch! Expected %d, got %d", test.name, len(test.expected), len(got))
continue
}
for k, exp := range test.expected {
g, ok := got[k]
if !ok {
t.Errorf("%s: Didn't find expected kind %s", test.name, k)
}
sort.Strings(g)
sort.Strings(exp)
if !reflect.DeepEqual(g, exp) {
t.Errorf("%s: Resource names mismatch! Expected %v, got %v", test.name, exp, g)
continue
}
}
}
}
func TestRunAll(t *testing.T) {
dockerSearcher := app.DockerRegistrySearcher{
Client: dockerregistry.NewClient(),
}
tests := []struct {
name string
config *AppConfig
expected map[string][]string
expectedName string
expectedErr error
expectInsecure sets.String
expectedVolumes map[string]string
checkPort string
}{
{
name: "successful ruby app generation",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
dockerSearcher: fakeDockerSearcher(),
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
Strategy: "source",
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"imageStream": {"ruby-hello-world", "ruby"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedVolumes: nil,
expectedErr: nil,
},
{
name: "successful ruby app generation with labels",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
dockerSearcher: fakeDockerSearcher(),
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
Strategy: "source",
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
Labels: map[string]string{"label1": "value1", "label2": "value2"},
},
expected: map[string][]string{
"imageStream": {"ruby-hello-world", "ruby"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedVolumes: nil,
expectedErr: nil,
},
{
name: "successful docker app generation",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
dockerSearcher: fakeSimpleDockerSearcher(),
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
Strategy: "docker",
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
checkPort: "8080",
expected: map[string][]string{
"imageStream": {"ruby-hello-world", "ruby-20-centos7"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedErr: nil,
},
{
name: "app generation using context dir",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/sti-ruby"}),
ContextDir: "2.0/test/rack-test-app",
dockerSearcher: dockerSearcher,
imageStreamSearcher: fakeImageStreamSearcher(),
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"imageStream": {"sti-ruby"},
"buildConfig": {"sti-ruby"},
"deploymentConfig": {"sti-ruby"},
"service": {"sti-ruby"},
},
expectedName: "sti-ruby",
expectedVolumes: nil,
expectedErr: nil,
},
{
name: "insecure registry generation",
config: &AppConfig{
Components: util.StringList([]string{"myrepo:5000/myco/example"}),
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
Strategy: "source",
dockerSearcher: app.DockerClientSearcher{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"myrepo:5000/myco/example"}}},
Image: dockerBuilderImage(),
},
Insecure: true,
RegistrySearcher: &ExactMatchDockerSearcher{},
},
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{},
},
templateFileSearcher: &app.TemplateFileSearcher{},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
InsecureRegistry: true,
},
expected: map[string][]string{
"imageStream": {"example", "ruby-hello-world"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedErr: nil,
expectedVolumes: nil,
expectInsecure: sets.NewString("example"),
},
{
name: "emptyDir volumes",
config: &AppConfig{
DockerImages: util.StringList([]string{"mysql"}),
dockerSearcher: dockerSearcher,
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"imageStream": {"mysql"},
"deploymentConfig": {"mysql"},
"service": {"mysql"},
"volumeMounts": {"mysql-volume-1"},
},
expectedName: "mysql",
expectedVolumes: map[string]string{
"mysql-volume-1": "EmptyDir",
},
expectedErr: nil,
},
{
name: "Docker build",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
dockerSearcher: app.DockerClientSearcher{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"openshift/ruby-20-centos7"}}},
Image: dockerBuilderImage(),
},
Insecure: true,
RegistrySearcher: &ExactMatchDockerSearcher{},
},
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"imageStream": {"ruby-hello-world", "ruby-20-centos7"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedErr: nil,
},
{
name: "Docker build with no registry image",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
dockerSearcher: app.DockerClientSearcher{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"openshift/ruby-20-centos7"}}},
Image: dockerBuilderImage(),
},
Insecure: true,
},
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationSearcher: app.NewImageStreamByAnnotationSearcher(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"imageStream": {"ruby-hello-world"},
"buildConfig": {"ruby-hello-world"},
"deploymentConfig": {"ruby-hello-world"},
"service": {"ruby-hello-world"},
},
expectedName: "ruby-hello-world",
expectedErr: nil,
},
{
name: "custom name",
config: &AppConfig{
DockerImages: util.StringList([]string{"mysql"}),
dockerSearcher: app.DockerClientSearcher{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"mysql"}}},
Image: &docker.Image{
Config: &docker.Config{
ExposedPorts: map[docker.Port]struct{}{
"8080/tcp": {},
},
},
},
},
RegistrySearcher: &ExactMatchDockerSearcher{},
},
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
Name: "custom",
},
expected: map[string][]string{
"imageStream": {"custom"},
"deploymentConfig": {"custom"},
"service": {"custom"},
},
expectedName: "custom",
expectedErr: nil,
},
}
for _, test := range tests {
test.config.refBuilder = &app.ReferenceBuilder{}
test.config.Out, test.config.ErrOut = os.Stdout, os.Stderr
res, err := test.config.RunAll()
if err != test.expectedErr {
t.Errorf("%s: Error mismatch! Expected %v, got %v", test.name, test.expectedErr, err)
continue
}
imageStreams := []*imageapi.ImageStream{}
got := map[string][]string{}
gotVolumes := map[string]string{}
for _, obj := range res.List.Items {
switch tp := obj.(type) {
case *buildapi.BuildConfig:
got["buildConfig"] = append(got["buildConfig"], tp.Name)
case *kapi.Service:
if test.checkPort != "" {
if len(tp.Spec.Ports) == 0 {
t.Errorf("%s: did not get any ports in service", test.name)
break
}
expectedPort, _ := strconv.Atoi(test.checkPort)
if tp.Spec.Ports[0].Port != expectedPort {
t.Errorf("%s: did not get expected port in service. Expected: %d. Got %d\n",
test.name, expectedPort, tp.Spec.Ports[0].Port)
}
}
if test.config.Labels != nil {
if !mapContains(test.config.Labels, tp.Spec.Selector) {
t.Errorf("%s: did not get expected service selector. Expected: %v. Got: %v",
test.name, test.config.Labels, tp.Spec.Selector)
}
}
got["service"] = append(got["service"], tp.Name)
case *imageapi.ImageStream:
got["imageStream"] = append(got["imageStream"], tp.Name)
imageStreams = append(imageStreams, tp)
case *deployapi.DeploymentConfig:
got["deploymentConfig"] = append(got["deploymentConfig"], tp.Name)
if podTemplate := tp.Template.ControllerTemplate.Template; podTemplate != nil {
for _, volume := range podTemplate.Spec.Volumes {
if volume.VolumeSource.EmptyDir != nil {
gotVolumes[volume.Name] = "EmptyDir"
} else {
gotVolumes[volume.Name] = "UNKNOWN"
}
}
for _, container := range podTemplate.Spec.Containers {
for _, volumeMount := range container.VolumeMounts {
got["volumeMounts"] = append(got["volumeMounts"], volumeMount.Name)
}
}
}
if test.config.Labels != nil {
if !mapContains(test.config.Labels, tp.Template.ControllerTemplate.Selector) {
t.Errorf("%s: did not get expected deployment config rc selector. Expected: %v. Got: %v",
test.name, test.config.Labels, tp.Template.ControllerTemplate.Selector)
}
}
}
}
if len(test.expected) != len(got) {
t.Errorf("%s: Resource kind size mismatch! Expected %d, got %d", test.name, len(test.expected), len(got))
continue
}
for k, exp := range test.expected {
g, ok := got[k]
if !ok {
t.Errorf("%s: Didn't find expected kind %s", test.name, k)
}
sort.Strings(g)
sort.Strings(exp)
if !reflect.DeepEqual(g, exp) {
t.Errorf("%s: %s resource names mismatch! Expected %v, got %v", test.name, k, exp, g)
continue
}
}
if len(test.expectedVolumes) != len(gotVolumes) {
t.Errorf("%s: Volume count mismatch! Expected %d, got %d", test.name, len(test.expectedVolumes), len(gotVolumes))
continue
}
for k, exp := range test.expectedVolumes {
g, ok := gotVolumes[k]
if !ok {
t.Errorf("%s: Didn't find expected volume %s", test.name, k)
}
if g != exp {
t.Errorf("%s: Expected volume of type %s, got %s", test.name, g, exp)
}
}
if test.expectedName != res.Name {
t.Errorf("%s: Unexpected name: %s", test.name, test.expectedName)
}
if test.expectInsecure == nil {
continue
}
for _, stream := range imageStreams {
_, hasAnnotation := stream.Annotations[imageapi.InsecureRepositoryAnnotation]
if test.expectInsecure.Has(stream.Name) && !hasAnnotation {
t.Errorf("%s: Expected insecure annotation for stream: %s, but did not get one.", test.name, stream.Name)
}
if !test.expectInsecure.Has(stream.Name) && hasAnnotation {
t.Errorf("%s: Got insecure annotation for stream: %s, and was not expecting one.", test.name, stream.Name)
}
}
}
}
func TestAddArguments(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "test-newapp")
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
defer os.RemoveAll(tmpDir)
testDir := filepath.Join(tmpDir, "test/one/two/three")
err = os.MkdirAll(testDir, 0777)
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
tests := map[string]struct {
args []string
env util.StringList
parms util.StringList
repos util.StringList
components util.StringList
unknown []string
}{
"components": {
args: []string{"one", "two+three", "four~five"},
components: util.StringList([]string{"one", "two+three", "four~five"}),
unknown: []string{},
},
"source": {
args: []string{".", testDir, "git://server/repo.git"},
repos: util.StringList([]string{".", testDir, "git://server/repo.git"}),
unknown: []string{},
},
"env": {
args: []string{"first=one", "second=two", "third=three"},
env: util.StringList([]string{"first=one", "second=two", "third=three"}),
unknown: []string{},
},
"mix 1": {
args: []string{"git://server/repo.git", "[email protected]/repo.git", "env1=test", "ruby-helloworld-sample"},
repos: util.StringList([]string{"git://server/repo.git"}),
components: util.StringList([]string{"[email protected]/repo.git", "ruby-helloworld-sample"}),
env: util.StringList([]string{"env1=test"}),
unknown: []string{},
},
}
for n, c := range tests {
a := AppConfig{}
unknown := a.AddArguments(c.args)
if !reflect.DeepEqual(a.Environment, c.env) {
t.Errorf("%s: Different env variables. Expected: %v, Actual: %v", n, c.env, a.Environment)
}
if !reflect.DeepEqual(a.SourceRepositories, c.repos) {
t.Errorf("%s: Different source repos. Expected: %v, Actual: %v", n, c.repos, a.SourceRepositories)
}
if !reflect.DeepEqual(a.Components, c.components) {
t.Errorf("%s: Different components. Expected: %v, Actual: %v", n, c.components, a.Components)
}
if !reflect.DeepEqual(unknown, c.unknown) {
t.Errorf("%s: Different unknown result. Expected: %v, Actual: %v", n, c.unknown, unknown)
}
}
}
func TestRunBuild(t *testing.T) {
dockerSearcher := app.DockerRegistrySearcher{
Client: dockerregistry.NewClient(),
}
tests := []struct {
name string
config *AppConfig
expected map[string][]string
expectedErr error
}{
{
name: "successful ruby app generation",
config: &AppConfig{
SourceRepositories: util.StringList([]string{"https://github.com/openshift/ruby-hello-world"}),
DockerImages: util.StringList([]string{"openshift/ruby-20-centos7", "openshift/mongodb-24-centos7"}),
OutputDocker: true,
dockerSearcher: dockerSearcher,
imageStreamSearcher: app.ImageStreamSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationSearcher: &app.ImageStreamByAnnotationSearcher{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateSearcher: app.TemplateSearcher{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{"openshift", "default"},
},
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
typer: kapi.Scheme,
osclient: &client.Fake{},
originNamespace: "default",
},
expected: map[string][]string{
"buildConfig": {"ruby-hello-world"},
"imageStream": {"ruby-20-centos7"},
},
expectedErr: nil,
},
}
for _, test := range tests {
test.config.refBuilder = &app.ReferenceBuilder{}
res, err := test.config.RunBuilds(os.Stdout, os.Stderr)
if err != test.expectedErr {
t.Errorf("%s: Error mismatch! Expected %v, got %v", test.name, test.expectedErr, err)
continue
}
got := map[string][]string{}
for _, obj := range res.List.Items {
switch tp := obj.(type) {
case *buildapi.BuildConfig:
got["buildConfig"] = append(got["buildConfig"], tp.Name)
case *imageapi.ImageStream:
got["imageStream"] = append(got["imageStream"], tp.Name)
}
}
if len(test.expected) != len(got) {
t.Errorf("%s: Resource kind size mismatch! Expected %d, got %d", test.name, len(test.expected), len(got))
continue
}
for k, exp := range test.expected {
g, ok := got[k]
if !ok {
t.Errorf("%s: Didn't find expected kind %s", test.name, k)
}
sort.Strings(g)
sort.Strings(exp)
if !reflect.DeepEqual(g, exp) {
t.Errorf("%s: Resource names mismatch! Expected %v, got %v", test.name, exp, g)
continue
}
}
}
}