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 }