func TestBuildTemplates(t *testing.T) {
tests := map[string]struct {
templateName string
namespace string
parms map[string]string
}{
"simple": {
templateName: "first-stored-template",
namespace: "default",
parms: map[string]string{},
},
}
for n, c := range tests {
appCfg := AppConfig{}
appCfg.refBuilder = &app.ReferenceBuilder{}
appCfg.SetOpenShiftClient(&client.Fake{}, c.namespace)
appCfg.AddArguments([]string{c.templateName})
appCfg.TemplateParameters = util.StringList{}
for k, v := range c.parms {
appCfg.TemplateParameters.Set(fmt.Sprintf("%v=%v", k, v))
}
components, _, _, parms, err := appCfg.validate()
if err != nil {
t.Errorf("%s: Unexpected error: %v", n, err)
}
err = appCfg.resolve(components)
if err != nil {
t.Errorf("%s: Unexpected error: %v", n, err)
}
_, err = appCfg.buildTemplates(components, app.Environment(parms))
if err != nil {
t.Errorf("%s: Unexpected error: %v", n, err)
}
for _, component := range components {
match := component.Input().Match
if !match.IsTemplate() {
t.Errorf("%s: Expected template match, got: %v", n, match)
}
if c.templateName != match.Name {
t.Errorf("%s: Expected template name %q, got: %q", n, c.templateName, match.Name)
}
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
}
}
}
}
}
// run executes the provided config applying provided acceptors.
func (c *AppConfig) run(out io.Writer, acceptors app.Acceptors) (*AppResult, error) {
c.ensureDockerResolver()
repositories, err := c.individualSourceRepositories()
if err != nil {
return nil, err
}
err = c.detectSource(repositories)
if err != nil {
return nil, err
}
components, repositories, environment, parameters, err := c.validate()
if err != nil {
return nil, err
}
if err := c.resolve(components); err != nil {
return nil, err
}
// Couple source with resolved builder components if possible
if err := c.ensureHasSource(components.NeedsSource(), repositories.NotUsed()); err != nil {
return nil, err
}
// For source repos that are not yet coupled with a component, create components
sourceComponents, err := c.componentsForRepos(repositories.NotUsed())
if err != nil {
return nil, err
}
// resolve the source repo components
if err := c.resolve(sourceComponents); err != nil {
return nil, err
}
components = append(components, sourceComponents...)
glog.V(4).Infof("Code %v", repositories)
glog.V(4).Infof("Components %v", components)
if len(repositories) == 0 && len(components) == 0 {
return nil, ErrNoInputs
}
pipelines, err := c.buildPipelines(components, app.Environment(environment))
if err != nil {
return nil, err
}
objects := app.Objects{}
accept := app.NewAcceptFirst()
for _, p := range pipelines {
accepted, err := p.Objects(accept, acceptors)
if err != nil {
return nil, fmt.Errorf("can't setup %q: %v", p.From, err)
}
objects = append(objects, accepted...)
}
objects = app.AddServices(objects)
templateObjects, err := c.buildTemplates(components, app.Environment(parameters))
if err != nil {
return nil, err
}
objects = append(objects, templateObjects...)
buildNames := []string{}
for _, obj := range objects {
switch t := obj.(type) {
case *buildapi.BuildConfig:
buildNames = append(buildNames, t.Name)
}
}
return &AppResult{
List: &kapi.List{Items: objects},
BuildNames: buildNames,
HasSource: len(repositories) != 0,
Namespace: c.originNamespace,
}, nil
}