diff --git a/vendor.conf b/vendor.conf index 1e9e72ff43..d27abce96a 100755 --- a/vendor.conf +++ b/vendor.conf @@ -22,6 +22,7 @@ github.com/docker/swarmkit 79381d0840be27f8b3f5c667b348a4467d866eeb github.com/flynn-archive/go-shlex 3f9db97f856818214da2e1057f8ad84803971cff github.com/gogo/protobuf 7efa791bd276fd4db00867cbd982b552627c24cb github.com/golang/protobuf 7a211bcf3bce0e3f1d74f9894916e6f116ae83b4 +github.com/gotestyourself/gotestyourself v1.0.0 github.com/gorilla/context v1.1 github.com/gorilla/mux v1.1 github.com/inconshreveable/mousetrap 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75 diff --git a/vendor/github.com/docker/docker/pkg/testutil/golden/golden.go b/vendor/github.com/docker/docker/pkg/testutil/golden/golden.go deleted file mode 100644 index 8f725da7bf..0000000000 --- a/vendor/github.com/docker/docker/pkg/testutil/golden/golden.go +++ /dev/null @@ -1,28 +0,0 @@ -// Package golden provides function and helpers to use golden file for -// testing purpose. -package golden - -import ( - "flag" - "io/ioutil" - "path/filepath" - "testing" -) - -var update = flag.Bool("test.update", false, "update golden file") - -// Get returns the golden file content. If the `test.update` is specified, it updates the -// file with the current output and returns it. -func Get(t *testing.T, actual []byte, filename string) []byte { - golden := filepath.Join("testdata", filename) - if *update { - if err := ioutil.WriteFile(golden, actual, 0644); err != nil { - t.Fatal(err) - } - } - expected, err := ioutil.ReadFile(golden) - if err != nil { - t.Fatal(err) - } - return expected -} diff --git a/vendor/github.com/docker/docker/pkg/testutil/tempfile/tempfile.go b/vendor/github.com/docker/docker/pkg/testutil/tempfile/tempfile.go deleted file mode 100644 index 01474babff..0000000000 --- a/vendor/github.com/docker/docker/pkg/testutil/tempfile/tempfile.go +++ /dev/null @@ -1,56 +0,0 @@ -package tempfile - -import ( - "io/ioutil" - "os" - - "github.com/stretchr/testify/require" -) - -// TempFile is a temporary file that can be used with unit tests. TempFile -// reduces the boilerplate setup required in each test case by handling -// setup errors. -type TempFile struct { - File *os.File -} - -// NewTempFile returns a new temp file with contents -func NewTempFile(t require.TestingT, prefix string, content string) *TempFile { - file, err := ioutil.TempFile("", prefix+"-") - require.NoError(t, err) - - _, err = file.Write([]byte(content)) - require.NoError(t, err) - file.Close() - return &TempFile{File: file} -} - -// Name returns the filename -func (f *TempFile) Name() string { - return f.File.Name() -} - -// Remove removes the file -func (f *TempFile) Remove() { - os.Remove(f.Name()) -} - -// TempDir is a temporary directory that can be used with unit tests. TempDir -// reduces the boilerplate setup required in each test case by handling -// setup errors. -type TempDir struct { - Path string -} - -// NewTempDir returns a new temp file with contents -func NewTempDir(t require.TestingT, prefix string) *TempDir { - path, err := ioutil.TempDir("", prefix+"-") - require.NoError(t, err) - - return &TempDir{Path: path} -} - -// Remove removes the file -func (f *TempDir) Remove() { - os.Remove(f.Path) -} diff --git a/vendor/github.com/gotestyourself/gotestyourself/LICENSE b/vendor/github.com/gotestyourself/gotestyourself/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/gotestyourself/gotestyourself/README.md b/vendor/github.com/gotestyourself/gotestyourself/README.md new file mode 100644 index 0000000000..2648074900 --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/README.md @@ -0,0 +1,32 @@ +# Go Test Yourself + +A collection of packages compatible with `go test` to support common testing +patterns. + +[![GoDoc](https://godoc.org/github.com/gotestyourself/gotestyourself?status.svg)](https://godoc.org/github.com/gotestyourself/gotestyourself) +[![CircleCI](https://circleci.com/gh/gotestyourself/gotestyourself/tree/master.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotestyourself/tree/master) +[![Go Reportcard](https://goreportcard.com/badge/github.com/gotestyourself/gotestyourself)](https://goreportcard.com/report/github.com/gotestyourself/gotestyourself) + + +## Packages + +* [fs](http://godoc.org/github.com/gotestyourself/gotestyourself/fs) - + create test files and directories +* [golden](http://godoc.org/github.com/gotestyourself/gotestyourself/golden) - + compare large multi-line strings +* [testsum](http://godoc.org/github.com/gotestyourself/gotestyourself/testsum) - + a program to summarize `go test` output and test failures +* [icmd](http://godoc.org/github.com/gotestyourself/gotestyourself/icmd) - + execute binaries and test the output +* [skip](http://godoc.org/github.com/gotestyourself/gotestyourself/skip) - + skip tests based on conditions + + +## Related + +* [testify/assert](https://godoc.org/github.com/stretchr/testify/assert) and + [testify/require](https://godoc.org/github.com/stretchr/testify/require) - + assertion libraries with common assertions +* [golang/mock](https://github.com/golang/mock) - generate mocks for interfaces +* [testify/suite](https://godoc.org/github.com/stretchr/testify/suite) - + group test into suites to share common setup/teardown logic diff --git a/vendor/github.com/gotestyourself/gotestyourself/fs/file.go b/vendor/github.com/gotestyourself/gotestyourself/fs/file.go new file mode 100644 index 0000000000..dcda10a02a --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/fs/file.go @@ -0,0 +1,81 @@ +/*Package fs provides tools for creating and working with temporary files and +directories. +*/ +package fs + +import ( + "io/ioutil" + "os" + "path/filepath" + + "github.com/stretchr/testify/require" +) + +// Path objects return their filesystem path. Both File and Dir implement Path. +type Path interface { + Path() string +} + +// File is a temporary file on the filesystem +type File struct { + path string +} + +// NewFile creates a new file in a temporary directory using prefix as part of +// the filename. The PathOps are applied to the before returning the File. +func NewFile(t require.TestingT, prefix string, ops ...PathOp) *File { + tempfile, err := ioutil.TempFile("", prefix+"-") + require.NoError(t, err) + file := &File{path: tempfile.Name()} + require.NoError(t, tempfile.Close()) + + for _, op := range ops { + require.NoError(t, op(file)) + } + return file +} + +// Path returns the full path to the file +func (f *File) Path() string { + return f.path +} + +// Remove the file +func (f *File) Remove() { + // nolint: errcheck + os.Remove(f.path) +} + +// Dir is a temporary directory +type Dir struct { + path string +} + +// NewDir returns a new temporary directory using prefix as part of the directory +// name. The PathOps are applied before returning the Dir. +func NewDir(t require.TestingT, prefix string, ops ...PathOp) *Dir { + path, err := ioutil.TempDir("", prefix+"-") + require.NoError(t, err) + dir := &Dir{path: path} + + for _, op := range ops { + require.NoError(t, op(dir)) + } + return dir +} + +// Path returns the full path to the directory +func (d *Dir) Path() string { + return d.path +} + +// Remove the directory +func (d *Dir) Remove() { + // nolint: errcheck + os.RemoveAll(d.path) +} + +// Join returns a new path with this directory as the base of the path +func (d *Dir) Join(parts ...string) string { + return filepath.Join(append([]string{d.Path()}, parts...)...) +} diff --git a/vendor/github.com/gotestyourself/gotestyourself/fs/ops.go b/vendor/github.com/gotestyourself/gotestyourself/fs/ops.go new file mode 100644 index 0000000000..4fbc40f422 --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/fs/ops.go @@ -0,0 +1,94 @@ +package fs + +import ( + "io/ioutil" + "os" + "path/filepath" +) + +// PathOp is a function which accepts a Path to perform some operation +type PathOp func(path Path) error + +// WithContent writes content to a file at Path +func WithContent(content string) PathOp { + return func(path Path) error { + return ioutil.WriteFile(path.Path(), []byte(content), 0644) + } +} + +// WithBytes write bytes to a file at Path +func WithBytes(raw []byte) PathOp { + return func(path Path) error { + return ioutil.WriteFile(path.Path(), raw, 0644) + } +} + +// AsUser changes ownership of the file system object at Path +func AsUser(uid, gid int) PathOp { + return func(path Path) error { + return os.Chown(path.Path(), uid, gid) + } +} + +// WithFile creates a file in the directory at path with content +func WithFile(filename, content string) PathOp { + return func(path Path) error { + return createFile(path.Path(), filename, content) + } +} + +func createFile(dir, filename, content string) error { + fullpath := filepath.Join(dir, filepath.FromSlash(filename)) + return ioutil.WriteFile(fullpath, []byte(content), 0644) +} + +// WithFiles creates all the files in the directory at path with their content +func WithFiles(files map[string]string) PathOp { + return func(path Path) error { + for filename, content := range files { + if err := createFile(path.Path(), filename, content); err != nil { + return err + } + } + return nil + } +} + +// FromDir copies the directory tree from the source path into the new Dir +func FromDir(source string) PathOp { + return func(path Path) error { + return copyDirectory(source, path.Path()) + } +} + +func copyDirectory(source, dest string) error { + entries, err := ioutil.ReadDir(source) + if err != nil { + return err + } + for _, entry := range entries { + sourcePath := filepath.Join(source, entry.Name()) + destPath := filepath.Join(dest, entry.Name()) + if entry.IsDir() { + if err := os.Mkdir(destPath, 0755); err != nil { + return err + } + if err := copyDirectory(sourcePath, destPath); err != nil { + return err + } + continue + } + if err := copyFile(sourcePath, destPath); err != nil { + return err + } + } + return nil +} + +func copyFile(source, dest string) error { + content, err := ioutil.ReadFile(source) + if err != nil { + return err + } + return ioutil.WriteFile(dest, content, 0644) +} diff --git a/vendor/github.com/gotestyourself/gotestyourself/golden/golden.go b/vendor/github.com/gotestyourself/gotestyourself/golden/golden.go new file mode 100644 index 0000000000..230ff685cd --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/golden/golden.go @@ -0,0 +1,71 @@ +/*Package golden provides tools for comparing large mutli-line strings. + +Golden files are files in the ./testdata/ subdirectory of the package under test. +*/ +package golden + +import ( + "flag" + "fmt" + "io/ioutil" + "path/filepath" + + "github.com/pmezard/go-difflib/difflib" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var flagUpdate = flag.Bool("test.update-golden", false, "update golden file") + +// Get returns the golden file content +func Get(t require.TestingT, filename string) []byte { + expected, err := ioutil.ReadFile(Path(filename)) + require.NoError(t, err) + return expected +} + +// Path returns the full path to a golden file +func Path(filename string) string { + return filepath.Join("testdata", filename) +} + +func update(t require.TestingT, filename string, actual []byte) { + if *flagUpdate { + err := ioutil.WriteFile(Path(filename), actual, 0644) + require.NoError(t, err) + } +} + +// Assert compares the actual content to the expected content in the golden file. +// If `--update-golden` is set then the actual content is written to the golden +// file. +// Returns whether the assertion was successful (true) or not (false) +func Assert(t require.TestingT, actual string, filename string, msgAndArgs ...interface{}) bool { + expected := Get(t, filename) + update(t, filename, []byte(actual)) + + if assert.ObjectsAreEqual(expected, []byte(actual)) { + return true + } + + diff, err := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ + A: difflib.SplitLines(string(expected)), + B: difflib.SplitLines(actual), + FromFile: "Expected", + ToFile: "Actual", + Context: 3, + }) + require.NoError(t, err, msgAndArgs...) + return assert.Fail(t, fmt.Sprintf("Not Equal: \n%s", diff), msgAndArgs...) +} + +// AssertBytes compares the actual result to the expected result in the golden +// file. If `--update-golden` is set then the actual content is written to the +// golden file. +// Returns whether the assertion was successful (true) or not (false) +// nolint: lll +func AssertBytes(t require.TestingT, actual []byte, filename string, msgAndArgs ...interface{}) bool { + expected := Get(t, filename) + update(t, filename, actual) + return assert.Equal(t, expected, actual, msgAndArgs...) +} diff --git a/vendor/github.com/gotestyourself/gotestyourself/skip/skip.go b/vendor/github.com/gotestyourself/gotestyourself/skip/skip.go new file mode 100644 index 0000000000..d92110b0ef --- /dev/null +++ b/vendor/github.com/gotestyourself/gotestyourself/skip/skip.go @@ -0,0 +1,133 @@ +/*Package skip provides functions for skipping based on a condition. + */ +package skip + +import ( + "bytes" + "fmt" + "go/ast" + "go/format" + "go/parser" + "go/token" + "io/ioutil" + "path" + "reflect" + "runtime" + "strings" + + "github.com/pkg/errors" +) + +type skipT interface { + Skip(args ...interface{}) + Log(args ...interface{}) +} + +// If skips the test if the check function returns true. The skip message will +// contain the name of the check function. Extra message text can be passed as a +// format string with args +func If(t skipT, check func() bool, msgAndArgs ...interface{}) { + if check() { + t.Skip(formatWithCustomMessage( + getFunctionName(check), + formatMessage(msgAndArgs...))) + } +} + +func getFunctionName(function func() bool) string { + funcPath := runtime.FuncForPC(reflect.ValueOf(function).Pointer()).Name() + return strings.SplitN(path.Base(funcPath), ".", 2)[1] +} + +// IfCondition skips the test if the condition is true. The skip message will +// contain the source of the expression passed as the condition. Extra message +// text can be passed as a format string with args. +func IfCondition(t skipT, condition bool, msgAndArgs ...interface{}) { + if !condition { + return + } + source, err := getConditionSource() + if err != nil { + t.Log(err.Error()) + t.Skip(formatMessage(msgAndArgs...)) + } + t.Skip(formatWithCustomMessage(source, formatMessage(msgAndArgs...))) +} + +func getConditionSource() (string, error) { + const callstackIndex = 3 + lines, err := getSourceLine(callstackIndex) + if err != nil { + return "", err + } + + for i := range lines { + source := strings.Join(lines[len(lines)-i-1:], "\n") + node, err := parser.ParseExpr(source) + if err == nil { + return getConditionArgFromAST(node) + } + } + return "", errors.Wrapf(err, "failed to parse source") +} + +// maxContextLines is the maximum number of lines to scan for a complete +// skip.If() statement +const maxContextLines = 10 + +// getSourceLines returns the source line which called skip.If() along with a +// few preceding lines. To properly parse the AST a complete statement is +// required, and that statement may be split across multiple lines, so include +// up to maxContextLines. +func getSourceLine(stackIndex int) ([]string, error) { + _, filename, line, ok := runtime.Caller(stackIndex) + if !ok { + return nil, errors.New("failed to get caller info") + } + + raw, err := ioutil.ReadFile(filename) + if err != nil { + return nil, errors.Wrapf(err, "failed to read source file: %s", filename) + } + + lines := strings.Split(string(raw), "\n") + if len(lines) < line { + return nil, errors.Errorf("file %s does not have line %d", filename, line) + } + firstLine := line - maxContextLines + if firstLine < 0 { + firstLine = 0 + } + return lines[firstLine:line], nil +} + +func getConditionArgFromAST(node ast.Expr) (string, error) { + switch expr := node.(type) { + case *ast.CallExpr: + buf := new(bytes.Buffer) + err := format.Node(buf, token.NewFileSet(), expr.Args[1]) + return buf.String(), err + } + return "", errors.New("unexpected ast") +} + +func formatMessage(msgAndArgs ...interface{}) string { + switch len(msgAndArgs) { + case 0: + return "" + case 1: + return msgAndArgs[0].(string) + default: + return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) + } +} + +func formatWithCustomMessage(source, custom string) string { + switch { + case custom == "": + return source + case source == "": + return custom + } + return fmt.Sprintf("%s: %s", source, custom) +}