// Create creates an ImportController.
func (f *ImportControllerFactory) Create() controller.RunnableController {
lw := &cache.ListWatch{
ListFunc: func() (runtime.Object, error) {
return f.Client.ImageStreams(kapi.NamespaceAll).List(labels.Everything(), fields.Everything())
},
WatchFunc: func(resourceVersion string) (watch.Interface, error) {
return f.Client.ImageStreams(kapi.NamespaceAll).Watch(labels.Everything(), fields.Everything(), resourceVersion)
},
}
q := cache.NewFIFO(cache.MetaNamespaceKeyFunc)
cache.NewReflector(lw, &api.ImageStream{}, q, 2*time.Minute).Run()
c := &ImportController{
client: dockerregistry.NewClient(),
streams: f.Client,
mappings: f.Client,
}
return &controller.RetryController{
Queue: q,
RetryManager: controller.NewQueueRetryManager(
q,
cache.MetaNamespaceKeyFunc,
func(obj interface{}, err error, retries controller.Retry) bool {
util.HandleError(err)
return retries.Count < 5
},
kutil.NewTokenBucketRateLimiter(1, 10),
),
Handle: func(obj interface{}) error {
r := obj.(*api.ImageStream)
return c.Next(r)
},
}
}
func TestDetectSource(t *testing.T) {
dockerResolver := app.DockerRegistryResolver{
Client: dockerregistry.NewClient(),
}
mocks := app.MockSourceRepositories()
tests := []struct {
name string
cfg *AppConfig
repositories []*app.SourceRepository
expectedLang string
expectedErr string
}{
{
name: "detect source - ruby",
cfg: &AppConfig{
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
dockerResolver: dockerResolver,
},
repositories: []*app.SourceRepository{mocks[1]},
expectedLang: "ruby",
expectedErr: "",
},
}
for _, test := range tests {
err := test.cfg.detectSource(test.repositories)
if err != nil {
if !strings.Contains(err.Error(), test.expectedErr) {
t.Errorf("%s: Invalid error: Expected %s, got %v", test.name, test.expectedErr, err)
}
} else if len(test.expectedErr) != 0 {
t.Errorf("%s: Expected %s error but got none", test.name, test.expectedErr)
}
for _, repo := range test.repositories {
info := repo.Info()
if info == nil {
t.Errorf("%s: expected repository info to be populated; it is nil", test.name)
continue
}
if term := strings.Join(info.Terms(), ","); term != test.expectedLang {
t.Errorf("%s: expected repository info term to be %s; got %s\n", test.name, test.expectedLang, term)
}
}
}
}
// NewAppConfig returns a new AppConfig
func NewAppConfig(typer runtime.ObjectTyper, mapper meta.RESTMapper, clientMapper resource.ClientMapper) *AppConfig {
dockerResolver := app.DockerRegistryResolver{
Client: dockerregistry.NewClient(),
}
return &AppConfig{
detector: app.SourceRepositoryEnumerator{
Detectors: source.DefaultDetectors,
Tester: dockerfile.NewTester(),
},
dockerResolver: dockerResolver,
typer: typer,
mapper: mapper,
clientMapper: clientMapper,
refBuilder: &app.ReferenceBuilder{},
}
}
func TestRunBuild(t *testing.T) {
dockerResolver := app.DockerRegistryResolver{
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{"https://github.com/openshift/ruby-hello-world"},
DockerImages: util.StringList{"openshift/ruby-20-centos7", "openshift/mongodb-24-centos7"},
OutputDocker: true,
dockerResolver: dockerResolver,
imageStreamResolver: app.ImageStreamResolver{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationResolver: &app.ImageStreamByAnnotationResolver{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateResolver: app.TemplateResolver{
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)
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
}
}
}
}
func TestRunAll(t *testing.T) {
dockerResolver := app.DockerRegistryResolver{
Client: dockerregistry.NewClient(),
}
tests := []struct {
name string
config *AppConfig
expected map[string][]string
expectedErr error
expectInsecure util.StringSet
}{
{
name: "successful ruby app generation",
config: &AppConfig{
SourceRepositories: util.StringList{"https://github.com/openshift/ruby-hello-world"},
dockerResolver: fakeDockerResolver(),
imageStreamResolver: app.ImageStreamResolver{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
Strategy: "source",
imageStreamByAnnotationResolver: app.NewImageStreamByAnnotationResolver(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateResolver: app.TemplateResolver{
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"},
},
expectedErr: nil,
},
{
name: "app generation using context dir",
config: &AppConfig{
SourceRepositories: util.StringList{"https://github.com/openshift/sti-ruby"},
ContextDir: "2.0/test/rack-test-app",
dockerResolver: dockerResolver,
imageStreamResolver: fakeImageStreamResolver(),
imageStreamByAnnotationResolver: app.NewImageStreamByAnnotationResolver(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateResolver: app.TemplateResolver{
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"},
},
expectedErr: nil,
},
{
name: "insecure registry generation",
config: &AppConfig{
Components: util.StringList{"myrepo:5000/myco/example"},
SourceRepositories: util.StringList{"https://github.com/openshift/ruby-hello-world"},
Strategy: "source",
dockerResolver: app.DockerClientResolver{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"myrepo:5000/myco/example"}}},
Image: dockerBuilderImage(),
},
Insecure: true,
},
imageStreamResolver: app.ImageStreamResolver{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
templateResolver: app.TemplateResolver{
Client: &client.Fake{},
TemplateConfigsNamespacer: &client.Fake{},
Namespaces: []string{},
},
templateFileResolver: &app.TemplateFileResolver{},
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"},
},
expectedErr: nil,
expectInsecure: util.NewStringSet("example"),
},
{
name: "docker build",
config: &AppConfig{
SourceRepositories: util.StringList{"https://github.com/openshift/ruby-hello-world"},
dockerResolver: app.DockerClientResolver{
Client: &dockertools.FakeDockerClient{
Images: []docker.APIImages{{RepoTags: []string{"openshift/ruby-20-centos7"}}},
Image: dockerBuilderImage(),
},
Insecure: true,
},
imageStreamResolver: app.ImageStreamResolver{
Client: &client.Fake{},
ImageStreamImages: &client.Fake{},
Namespaces: []string{"default"},
},
imageStreamByAnnotationResolver: app.NewImageStreamByAnnotationResolver(&client.Fake{}, &client.Fake{}, []string{"default"}),
templateResolver: app.TemplateResolver{
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"},
},
expectedErr: nil,
},
}
for _, test := range tests {
test.config.refBuilder = &app.ReferenceBuilder{}
res, err := test.config.RunAll(os.Stdout)
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{}
for _, obj := range res.List.Items {
switch tp := obj.(type) {
case *buildapi.BuildConfig:
got["buildConfig"] = append(got["buildConfig"], tp.Name)
case *kapi.Service:
got["service"] = append(got["service"], tp.Name)
case *imageapi.ImageStream:
got["imageStream"] = append(got["imageStream"], tp.Name)
imageStreams = append(imageStreams, tp)
case *deploy.DeploymentConfig:
got["deploymentConfig"] = append(got["deploymentConfig"], 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: %s resource names mismatch! Expected %v, got %v", test.name, k, exp, g)
continue
}
}
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 TestResolve(t *testing.T) {
tests := []struct {
name string
cfg AppConfig
components app.ComponentReferences
expectedErr string
}{
{
name: "Resolver error",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
Value: "mysql:invalid",
Resolver: app.DockerRegistryResolver{
Client: dockerregistry.NewClient(),
},
})},
expectedErr: `tag "invalid" has not been set`,
},
{
name: "Successful mysql builder",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
Value: "mysql",
Match: &app.ComponentMatch{
Builder: true,
},
})},
expectedErr: "",
},
{
name: "Unable to build source code",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
Value: "mysql",
ExpectToBuild: true,
})},
expectedErr: "no resolver",
},
{
name: "Successful docker build",
cfg: AppConfig{
Strategy: "docker",
},
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
Value: "mysql",
ExpectToBuild: true,
})},
expectedErr: "",
},
}
for _, test := range tests {
err := test.cfg.resolve(test.components)
if err != nil {
if !strings.Contains(err.Error(), test.expectedErr) {
t.Errorf("%s: Invalid error: Expected %s, got %v", test.name, test.expectedErr, err)
}
} else if len(test.expectedErr) != 0 {
t.Errorf("%s: Expected %s error but got none", test.name, test.expectedErr)
}
}
}
func (c *AppConfig) dockerRegistryResolver() app.Resolver {
return app.DockerRegistryResolver{
Client: dockerregistry.NewClient(),
AllowInsecure: c.InsecureRegistry,
}
}