1
0
mirror of https://github.com/ko-build/ko.git synced 2024-12-12 08:54:09 +02:00
ko-build/pkg/resolve/resolve_test.go
Jason Hall 3315663a21 Remove strictness checks from build, into resolve
Strictness has nothing to do with building, and is independent of how
images are built (fixed builder, some future exotic builder type, etc.)
2019-08-15 14:22:45 -04:00

360 lines
10 KiB
Go

// Copyright 2018 Google LLC All Rights Reserved.
//
// 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.
package resolve
import (
"bytes"
"io"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/google/go-containerregistry/pkg/name"
v1 "github.com/google/go-containerregistry/pkg/v1"
"github.com/google/go-containerregistry/pkg/v1/random"
yaml "gopkg.in/yaml.v2"
)
var (
fooRef = "github.com/awesomesauce/foo"
foo = mustRandom()
fooHash = mustDigest(foo)
barRef = "github.com/awesomesauce/bar"
bar = mustRandom()
barHash = mustDigest(bar)
bazRef = "github.com/awesomesauce/baz"
baz = mustRandom()
bazHash = mustDigest(baz)
testBuilder = newFixedBuild(map[string]v1.Image{
fooRef: foo,
barRef: bar,
bazRef: baz,
})
testHashes = map[string]v1.Hash{
fooRef: fooHash,
barRef: barHash,
bazRef: bazHash,
}
)
func TestYAMLArrays(t *testing.T) {
tests := []struct {
desc string
refs []string
hashes []v1.Hash
base name.Repository
}{{
desc: "singleton array",
refs: []string{fooRef},
hashes: []v1.Hash{fooHash},
base: mustRepository("gcr.io/mattmoor"),
}, {
desc: "singleton array (different base)",
refs: []string{fooRef},
hashes: []v1.Hash{fooHash},
base: mustRepository("gcr.io/jasonhall"),
}, {
desc: "two element array",
refs: []string{fooRef, barRef},
hashes: []v1.Hash{fooHash, barHash},
base: mustRepository("gcr.io/jonjohnson"),
}, {
desc: "empty array",
refs: []string{},
hashes: []v1.Hash{},
base: mustRepository("gcr.io/blah"),
}}
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
inputStructured := test.refs
inputYAML, err := yaml.Marshal(inputStructured)
if err != nil {
t.Fatalf("yaml.Marshal(%v) = %v", inputStructured, err)
}
outYAML, err := ImageReferences(inputYAML, false, testBuilder, newFixedPublish(test.base, testHashes))
if err != nil {
t.Fatalf("ImageReferences(%v) = %v", string(inputYAML), err)
}
var outStructured []string
if err := yaml.Unmarshal(outYAML, &outStructured); err != nil {
t.Errorf("yaml.Unmarshal(%v) = %v", string(outYAML), err)
}
if want, got := len(inputStructured), len(outStructured); want != got {
t.Errorf("ImageReferences(%v) = %v, want %v", string(inputYAML), got, want)
}
var expectedStructured []string
for i, ref := range test.refs {
hash := test.hashes[i]
expectedStructured = append(expectedStructured,
computeDigest(test.base, ref, hash))
}
if diff := cmp.Diff(expectedStructured, outStructured, cmpopts.EquateEmpty()); diff != "" {
t.Errorf("ImageReferences(%v); (-want +got) = %v", string(inputYAML), diff)
}
})
}
}
func TestYAMLMaps(t *testing.T) {
base := mustRepository("gcr.io/mattmoor")
tests := []struct {
desc string
input map[string]string
expected map[string]string
}{{
desc: "simple value",
input: map[string]string{"image": fooRef},
expected: map[string]string{"image": computeDigest(base, fooRef, fooHash)},
}, {
desc: "simple key",
input: map[string]string{bazRef: "blah"},
expected: map[string]string{
computeDigest(base, bazRef, bazHash): "blah",
},
}, {
desc: "key and value",
input: map[string]string{fooRef: barRef},
expected: map[string]string{
computeDigest(base, fooRef, fooHash): computeDigest(base, barRef, barHash),
},
}, {
desc: "empty map",
input: map[string]string{},
expected: map[string]string{},
}, {
desc: "multiple values",
input: map[string]string{
"arg1": fooRef,
"arg2": barRef,
},
expected: map[string]string{
"arg1": computeDigest(base, fooRef, fooHash),
"arg2": computeDigest(base, barRef, barHash),
},
}}
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
inputStructured := test.input
inputYAML, err := yaml.Marshal(inputStructured)
if err != nil {
t.Fatalf("yaml.Marshal(%v) = %v", inputStructured, err)
}
outYAML, err := ImageReferences(inputYAML, false, testBuilder, newFixedPublish(base, testHashes))
if err != nil {
t.Fatalf("ImageReferences(%v) = %v", string(inputYAML), err)
}
var outStructured map[string]string
if err := yaml.Unmarshal(outYAML, &outStructured); err != nil {
t.Errorf("yaml.Unmarshal(%v) = %v", string(outYAML), err)
}
if want, got := len(inputStructured), len(outStructured); want != got {
t.Errorf("ImageReferences(%v) = %v, want %v", string(inputYAML), got, want)
}
if diff := cmp.Diff(test.expected, outStructured, cmpopts.EquateEmpty()); diff != "" {
t.Errorf("ImageReferences(%v); (-want +got) = %v", string(inputYAML), diff)
}
})
}
}
// object has public fields to avoid `yaml:"foo"` annotations.
type object struct {
S string
M map[string]object
A []object
P *object
}
func TestYAMLObject(t *testing.T) {
base := mustRepository("gcr.io/bazinga")
tests := []struct {
desc string
input *object
expected *object
}{{
desc: "empty object",
input: &object{},
expected: &object{},
}, {
desc: "string field",
input: &object{S: fooRef},
expected: &object{S: computeDigest(base, fooRef, fooHash)},
}, {
desc: "map field",
input: &object{M: map[string]object{"blah": {S: fooRef}}},
expected: &object{M: map[string]object{"blah": {S: computeDigest(base, fooRef, fooHash)}}},
}, {
desc: "array field",
input: &object{A: []object{{S: fooRef}}},
expected: &object{A: []object{{S: computeDigest(base, fooRef, fooHash)}}},
}, {
desc: "pointer field",
input: &object{P: &object{S: fooRef}},
expected: &object{P: &object{S: computeDigest(base, fooRef, fooHash)}},
}, {
desc: "deep field",
input: &object{M: map[string]object{"blah": {A: []object{{P: &object{S: fooRef}}}}}},
expected: &object{M: map[string]object{"blah": {A: []object{{P: &object{S: computeDigest(base, fooRef, fooHash)}}}}}},
}}
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
inputStructured := test.input
inputYAML, err := yaml.Marshal(inputStructured)
if err != nil {
t.Fatalf("yaml.Marshal(%v) = %v", inputStructured, err)
}
outYAML, err := ImageReferences(inputYAML, false, testBuilder, newFixedPublish(base, testHashes))
if err != nil {
t.Fatalf("ImageReferences(%v) = %v", string(inputYAML), err)
}
var outStructured *object
if err := yaml.Unmarshal(outYAML, &outStructured); err != nil {
t.Errorf("yaml.Unmarshal(%v) = %v", string(outYAML), err)
}
if diff := cmp.Diff(test.expected, outStructured, cmpopts.EquateEmpty()); diff != "" {
t.Errorf("ImageReferences(%v); (-want +got) = %v", string(inputYAML), diff)
}
})
}
}
func TestStrict(t *testing.T) {
refs := []string{
"ko://" + fooRef,
"ko://" + barRef,
}
buf := bytes.NewBuffer(nil)
encoder := yaml.NewEncoder(buf)
for _, input := range refs {
if err := encoder.Encode(input); err != nil {
t.Fatalf("Encode(%v) = %v", input, err)
}
}
inputYAML := buf.Bytes()
base := mustRepository("gcr.io/multi-pass")
outYAML, err := ImageReferences(inputYAML, true, testBuilder, newFixedPublish(base, testHashes))
if err != nil {
t.Fatalf("ImageReferences: %v", err)
}
t.Log(string(outYAML))
}
func TestMultiDocumentYAMLs(t *testing.T) {
for _, test := range []struct {
desc string
refs []string
hashes []v1.Hash
base name.Repository
}{{
desc: "two string documents",
refs: []string{fooRef, barRef},
hashes: []v1.Hash{fooHash, barHash},
base: mustRepository("gcr.io/multi-pass"),
}} {
t.Run(test.desc, func(t *testing.T) {
buf := bytes.NewBuffer(nil)
encoder := yaml.NewEncoder(buf)
for _, input := range test.refs {
if err := encoder.Encode(input); err != nil {
t.Fatalf("Encode(%v) = %v", input, err)
}
}
inputYAML := buf.Bytes()
outYAML, err := ImageReferences(inputYAML, false, testBuilder, newFixedPublish(test.base, testHashes))
if err != nil {
t.Fatalf("ImageReferences(%v) = %v", string(inputYAML), err)
}
buf = bytes.NewBuffer(outYAML)
decoder := yaml.NewDecoder(buf)
var outStructured []string
for {
var output string
if err := decoder.Decode(&output); err == nil {
outStructured = append(outStructured, output)
} else if err == io.EOF {
outStructured = append(outStructured, output)
break
} else {
t.Errorf("yaml.Unmarshal(%v) = %v", string(outYAML), err)
}
}
var expectedStructured []string
for i, ref := range test.refs {
hash := test.hashes[i]
expectedStructured = append(expectedStructured,
computeDigest(test.base, ref, hash))
}
// The multi-document output always seems to leave a trailing --- so we end up with
// an extra empty element.
expectedStructured = append(expectedStructured, "")
if want, got := len(expectedStructured), len(outStructured); want != got {
t.Errorf("ImageReferences(%v) = %v, want %v", string(inputYAML), got, want)
}
if diff := cmp.Diff(expectedStructured, outStructured, cmpopts.EquateEmpty()); diff != "" {
t.Errorf("ImageReferences(%v); (-want +got) = %v", string(inputYAML), diff)
}
})
}
}
func mustRandom() v1.Image {
img, err := random.Image(1024, 5)
if err != nil {
panic(err)
}
return img
}
func mustRepository(s string) name.Repository {
n, err := name.NewRepository(s)
if err != nil {
panic(err)
}
return n
}
func mustDigest(img v1.Image) v1.Hash {
d, err := img.Digest()
if err != nil {
panic(err)
}
return d
}
func computeDigest(base name.Repository, ref string, h v1.Hash) string {
d, err := newFixedPublish(base, map[string]v1.Hash{ref: h}).Publish(nil, ref)
if err != nil {
panic(err)
}
return d.String()
}