func()

in codegen/mockgen.go [81:153]
63 lines of code
10 McCabe index (conditional complexity)

func (m MockgenBin) AugmentMockWithFixture(pkg *model.Package, f *Fixture, intf string) ([]byte, []byte, error) {
	methodsMap := make(map[string]*model.Method, len(pkg.Interfaces[0].Methods))
	validationMap := make(map[string]interface{}, len(pkg.Interfaces[0].Methods))
	for _, m := range pkg.Interfaces[0].Methods {
		methodsMap[m.Name] = m
		validationMap[m.Name] = struct{}{}
	}

	if err := f.Validate(validationMap); err != nil {
		return nil, nil, errors.Wrap(err, "invalid fixture config")
	}

	exposedMethods := make([]*model.Method, 0, len(f.Scenarios))
	for name := range f.Scenarios {
		exposedMethods = append(exposedMethods, methodsMap[name])
	}

	// sort methods in given fixture config for predictable fixture type generation
	sort.Sort(byMethodName(exposedMethods))

	pkgPathToAlias := uniqueAlias(pkg.Imports())
	methods := make([]*reflectMethod, 0, len(exposedMethods))
	for _, m := range exposedMethods {
		numIn := len(m.In)
		in := make(map[string]string, numIn)
		inString := make([]string, 0, numIn)
		for i, param := range m.In {
			arg := "arg" + strconv.Itoa(i)
			in[arg] = param.Type.String(pkgPathToAlias, "")
			inString = append(inString, arg)
		}

		numOut := len(m.Out)
		out := make(map[string]string, numOut)
		outString := make([]string, 0, numOut)
		for i, param := range m.Out {
			ret := "ret" + strconv.Itoa(i)
			out[ret] = param.Type.String(pkgPathToAlias, "")
			outString = append(outString, ret)
		}

		method := &reflectMethod{
			Name:      m.Name,
			In:        in,
			Out:       out,
			InString:  strings.Join(inString, " ,"),
			OutString: strings.Join(outString, " ,"),
		}

		if m.Variadic != nil {
			method.Variadic = "arg" + strconv.Itoa(len(m.In))
			method.VariadicType = m.Variadic.Type.String(pkgPathToAlias, "")
		}

		methods = append(methods, method)
	}

	data := map[string]interface{}{
		"Imports":         pkgPathToAlias,
		"Methods":         methods,
		"Fixture":         f,
		"ClientInterface": intf,
	}
	types, err := m.tmpl.ExecTemplate("fixture_types.tmpl", data, m.pkgHelper)
	if err != nil {
		return nil, nil, err
	}
	mock, err := m.tmpl.ExecTemplate("augmented_mock.tmpl", data, m.pkgHelper)
	if err != nil {
		return nil, nil, err
	}
	return types, mock, nil
}