kubernetes-sigs/kustomize
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/kustomize.git synced 2026-07-17 09:49:13 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

dep ensure

Browse Source
This commit is contained in:
Benjamin Elder
2018-10-24 17:24:58 -07:00
parent 41845522f6
commit 163515c5a0
6525 changed files with 84 additions and 3291220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
vendor/github.com/hashicorp/go-version/.travis.yml generated vendored
View File

@@ -1,13 +0,0 @@
language: go
go:
- 1.0
- 1.1
- 1.2
- 1.3
- 1.4
- 1.9
- "1.10"
script:
- go test

65
vendor/github.com/hashicorp/go-version/README.md generated vendored
View File

@@ -1,65 +0,0 @@
# Versioning Library for Go
[![Build Status](https://travis-ci.org/hashicorp/go-version.svg?branch=master)](https://travis-ci.org/hashicorp/go-version)
go-version is a library for parsing versions and version constraints,
and verifying versions against a set of constraints. go-version
can sort a collection of versions properly, handles prerelease/beta
versions, can increment versions, etc.
Versions used with go-version must follow [SemVer](http://semver.org/).
## Installation and Usage
Package documentation can be found on
[GoDoc](http://godoc.org/github.com/hashicorp/go-version).
Installation can be done with a normal `go get`:
```
$ go get github.com/hashicorp/go-version
```
#### Version Parsing and Comparison
```go
v1, err := version.NewVersion("1.2")
v2, err := version.NewVersion("1.5+metadata")
// Comparison example. There is also GreaterThan, Equal, and just
// a simple Compare that returns an int allowing easy >=, <=, etc.
if v1.LessThan(v2) {
fmt.Printf("%s is less than %s", v1, v2)
}
```
#### Version Constraints
```go
v1, err := version.NewVersion("1.2")
// Constraints example.
constraints, err := version.NewConstraint(">= 1.0, < 1.4")
if constraints.Check(v1) {
fmt.Printf("%s satisfies constraints %s", v1, constraints)
}
```
#### Version Sorting
```go
versionsRaw := []string{"1.1", "0.7.1", "1.4-beta", "1.4", "2"}
versions := make([]*version.Version, len(versionsRaw))
for i, raw := range versionsRaw {
v, _ := version.NewVersion(raw)
versions[i] = v
}
// After this, the versions are properly sorted
sort.Sort(version.Collection(versions))
```
## Issues and Contributing
If you find an issue with this library, please report an issue. If you'd
like, we welcome any contributions. Fork this library and submit a pull
request.

126
vendor/github.com/hashicorp/go-version/constraint_test.go generated vendored
View File

@@ -1,126 +0,0 @@
package version
import (
"testing"
)
func TestNewConstraint(t *testing.T) {
cases := []struct {
input string
count int
err bool
}{
{">= 1.2", 1, false},
{"1.0", 1, false},
{">= 1.x", 0, true},
{">= 1.2, < 1.0", 2, false},
// Out of bounds
{"11387778780781445675529500000000000000000", 0, true},
}
for _, tc := range cases {
v, err := NewConstraint(tc.input)
if tc.err && err == nil {
t.Fatalf("expected error for input: %s", tc.input)
} else if !tc.err && err != nil {
t.Fatalf("error for input %s: %s", tc.input, err)
}
if len(v) != tc.count {
t.Fatalf("input: %s\nexpected len: %d\nactual: %d",
tc.input, tc.count, len(v))
}
}
}
func TestConstraintCheck(t *testing.T) {
cases := []struct {
constraint string
version string
check bool
}{
{">= 1.0, < 1.2", "1.1.5", true},
{"< 1.0, < 1.2", "1.1.5", false},
{"= 1.0", "1.1.5", false},
{"= 1.0", "1.0.0", true},
{"1.0", "1.0.0", true},
{"~> 1.0", "2.0", false},
{"~> 1.0", "1.1", true},
{"~> 1.0", "1.2.3", true},
{"~> 1.0.0", "1.2.3", false},
{"~> 1.0.0", "1.0.7", true},
{"~> 1.0.0", "1.1.0", false},
{"~> 1.0.7", "1.0.4", false},
{"~> 1.0.7", "1.0.7", true},
{"~> 1.0.7", "1.0.8", true},
{"~> 1.0.7", "1.0.7.5", true},
{"~> 1.0.7", "1.0.6.99", false},
{"~> 1.0.7", "1.0.8.0", true},
{"~> 1.0.9.5", "1.0.9.5", true},
{"~> 1.0.9.5", "1.0.9.4", false},
{"~> 1.0.9.5", "1.0.9.6", true},
{"~> 1.0.9.5", "1.0.9.5.0", true},
{"~> 1.0.9.5", "1.0.9.5.1", true},
{"~> 2.0", "2.1.0-beta", false},
{"~> 2.1.0-a", "2.2.0", false},
{"~> 2.1.0-a", "2.1.0", false},
{"~> 2.1.0-a", "2.1.0-beta", true},
{"~> 2.1.0-a", "2.2.0-alpha", false},
{"> 2.0", "2.1.0-beta", false},
{">= 2.1.0-a", "2.1.0-beta", true},
{">= 2.1.0-a", "2.1.1-beta", false},
{">= 2.0.0", "2.1.0-beta", false},
{">= 2.1.0-a", "2.1.1", true},
{">= 2.1.0-a", "2.1.1-beta", false},
{">= 2.1.0-a", "2.1.0", true},
{"<= 2.1.0-a", "2.0.0", true},
}
for _, tc := range cases {
c, err := NewConstraint(tc.constraint)
if err != nil {
t.Fatalf("err: %s", err)
}
v, err := NewVersion(tc.version)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := c.Check(v)
expected := tc.check
if actual != expected {
t.Fatalf("Version: %s\nConstraint: %s\nExpected: %#v",
tc.version, tc.constraint, expected)
}
}
}
func TestConstraintsString(t *testing.T) {
cases := []struct {
constraint string
result string
}{
{">= 1.0, < 1.2", ""},
{"~> 1.0.7", ""},
}
for _, tc := range cases {
c, err := NewConstraint(tc.constraint)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := c.String()
expected := tc.result
if expected == "" {
expected = tc.constraint
}
if actual != expected {
t.Fatalf("Constraint: %s\nExpected: %#v\nActual: %s",
tc.constraint, expected, actual)
}
}
}

46
vendor/github.com/hashicorp/go-version/version_collection_test.go generated vendored
View File

@@ -1,46 +0,0 @@
package version
import (
"reflect"
"sort"
"testing"
)
func TestCollection(t *testing.T) {
versionsRaw := []string{
"1.1.1",
"1.0",
"1.2",
"2",
"0.7.1",
}
versions := make([]*Version, len(versionsRaw))
for i, raw := range versionsRaw {
v, err := NewVersion(raw)
if err != nil {
t.Fatalf("err: %s", err)
}
versions[i] = v
}
sort.Sort(Collection(versions))
actual := make([]string, len(versions))
for i, v := range versions {
actual[i] = v.String()
}
expected := []string{
"0.7.1",
"1.0.0",
"1.1.1",
"1.2.0",
"2.0.0",
}
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("bad: %#v", actual)
}
}

282
vendor/github.com/hashicorp/go-version/version_test.go generated vendored
View File

@@ -1,282 +0,0 @@
package version
import (
"reflect"
"testing"
)
func TestNewVersion(t *testing.T) {
cases := []struct {
version string
err bool
}{
{"1.2.3", false},
{"1.0", false},
{"1", false},
{"1.2.beta", true},
{"1.21.beta", true},
{"foo", true},
{"1.2-5", false},
{"1.2-beta.5", false},
{"\n1.2", true},
{"1.2.0-x.Y.0+metadata", false},
{"1.2.0-x.Y.0+metadata-width-hypen", false},
{"1.2.3-rc1-with-hypen", false},
{"1.2.3.4", false},
{"1.2.0.4-x.Y.0+metadata", false},
{"1.2.0.4-x.Y.0+metadata-width-hypen", false},
{"1.2.0-X-1.2.0+metadata~dist", false},
{"1.2.3.4-rc1-with-hypen", false},
{"1.2.3.4", false},
{"v1.2.3", false},
{"foo1.2.3", true},
{"1.7rc2", false},
{"v1.7rc2", false},
}
for _, tc := range cases {
_, err := NewVersion(tc.version)
if tc.err && err == nil {
t.Fatalf("expected error for version: %s", tc.version)
} else if !tc.err && err != nil {
t.Fatalf("error for version %s: %s", tc.version, err)
}
}
}
func TestVersionCompare(t *testing.T) {
cases := []struct {
v1 string
v2 string
expected int
}{
{"1.2.3", "1.4.5", -1},
{"1.2-beta", "1.2-beta", 0},
{"1.2", "1.1.4", 1},
{"1.2", "1.2-beta", 1},
{"1.2+foo", "1.2+beta", 0},
{"v1.2", "v1.2-beta", 1},
{"v1.2+foo", "v1.2+beta", 0},
{"v1.2.3.4", "v1.2.3.4", 0},
{"v1.2.0.0", "v1.2", 0},
{"v1.2.0.0.1", "v1.2", 1},
{"v1.2", "v1.2.0.0", 0},
{"v1.2", "v1.2.0.0.1", -1},
{"v1.2.0.0", "v1.2.0.0.1", -1},
{"v1.2.3.0", "v1.2.3.4", -1},
{"1.7rc2", "1.7rc1", 1},
{"1.7rc2", "1.7", -1},
{"1.2.0", "1.2.0-X-1.2.0+metadata~dist", 1},
}
for _, tc := range cases {
v1, err := NewVersion(tc.v1)
if err != nil {
t.Fatalf("err: %s", err)
}
v2, err := NewVersion(tc.v2)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v1.Compare(v2)
expected := tc.expected
if actual != expected {
t.Fatalf(
"%s <=> %s\nexpected: %d\nactual: %d",
tc.v1, tc.v2,
expected, actual)
}
}
}
func TestComparePreReleases(t *testing.T) {
cases := []struct {
v1 string
v2 string
expected int
}{
{"1.2-beta.2", "1.2-beta.2", 0},
{"1.2-beta.1", "1.2-beta.2", -1},
{"1.2-beta.2", "1.2-beta.11", -1},
{"3.2-alpha.1", "3.2-alpha", 1},
{"1.2-beta.2", "1.2-beta.1", 1},
{"1.2-beta.11", "1.2-beta.2", 1},
{"1.2-beta", "1.2-beta.3", -1},
{"1.2-alpha", "1.2-beta.3", -1},
{"1.2-beta", "1.2-alpha.3", 1},
{"3.0-alpha.3", "3.0-rc.1", -1},
{"3.0-alpha3", "3.0-rc1", -1},
{"3.0-alpha.1", "3.0-alpha.beta", -1},
{"5.4-alpha", "5.4-alpha.beta", 1},
{"v1.2-beta.2", "v1.2-beta.2", 0},
{"v1.2-beta.1", "v1.2-beta.2", -1},
{"v3.2-alpha.1", "v3.2-alpha", 1},
{"v3.2-rc.1-1-g123", "v3.2-rc.2", 1},
}
for _, tc := range cases {
v1, err := NewVersion(tc.v1)
if err != nil {
t.Fatalf("err: %s", err)
}
v2, err := NewVersion(tc.v2)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v1.Compare(v2)
expected := tc.expected
if actual != expected {
t.Fatalf(
"%s <=> %s\nexpected: %d\nactual: %d",
tc.v1, tc.v2,
expected, actual)
}
}
}
func TestVersionMetadata(t *testing.T) {
cases := []struct {
version string
expected string
}{
{"1.2.3", ""},
{"1.2-beta", ""},
{"1.2.0-x.Y.0", ""},
{"1.2.0-x.Y.0+metadata", "metadata"},
{"1.2.0-metadata-1.2.0+metadata~dist", "metadata~dist"},
}
for _, tc := range cases {
v, err := NewVersion(tc.version)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v.Metadata()
expected := tc.expected
if actual != expected {
t.Fatalf("expected: %s\nactual: %s", expected, actual)
}
}
}
func TestVersionPrerelease(t *testing.T) {
cases := []struct {
version string
expected string
}{
{"1.2.3", ""},
{"1.2-beta", "beta"},
{"1.2.0-x.Y.0", "x.Y.0"},
{"1.2.0-7.Y.0", "7.Y.0"},
{"1.2.0-x.Y.0+metadata", "x.Y.0"},
{"1.2.0-metadata-1.2.0+metadata~dist", "metadata-1.2.0"},
{"17.03.0-ce", "ce"}, // zero-padded fields
}
for _, tc := range cases {
v, err := NewVersion(tc.version)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v.Prerelease()
expected := tc.expected
if actual != expected {
t.Fatalf("expected: %s\nactual: %s", expected, actual)
}
}
}
func TestVersionSegments(t *testing.T) {
cases := []struct {
version string
expected []int
}{
{"1.2.3", []int{1, 2, 3}},
{"1.2-beta", []int{1, 2, 0}},
{"1-x.Y.0", []int{1, 0, 0}},
{"1.2.0-x.Y.0+metadata", []int{1, 2, 0}},
{"1.2.0-metadata-1.2.0+metadata~dist", []int{1, 2, 0}},
{"17.03.0-ce", []int{17, 3, 0}}, // zero-padded fields
}
for _, tc := range cases {
v, err := NewVersion(tc.version)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v.Segments()
expected := tc.expected
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("expected: %#v\nactual: %#v", expected, actual)
}
}
}
func TestVersionSegments64(t *testing.T) {
cases := []struct {
version string
expected []int64
}{
{"1.2.3", []int64{1, 2, 3}},
{"1.2-beta", []int64{1, 2, 0}},
{"1-x.Y.0", []int64{1, 0, 0}},
{"1.2.0-x.Y.0+metadata", []int64{1, 2, 0}},
{"1.4.9223372036854775807", []int64{1, 4, 9223372036854775807}},
}
for _, tc := range cases {
v, err := NewVersion(tc.version)
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v.Segments64()
expected := tc.expected
if !reflect.DeepEqual(actual, expected) {
t.Fatalf("expected: %#v\nactual: %#v", expected, actual)
}
{
expected := actual[0]
actual[0]++
actual = v.Segments64()
if actual[0] != expected {
t.Fatalf("Segments64 is mutable")
}
}
}
}
func TestVersionString(t *testing.T) {
cases := [][]string{
{"1.2.3", "1.2.3"},
{"1.2-beta", "1.2.0-beta"},
{"1.2.0-x.Y.0", "1.2.0-x.Y.0"},
{"1.2.0-x.Y.0+metadata", "1.2.0-x.Y.0+metadata"},
{"1.2.0-metadata-1.2.0+metadata~dist", "1.2.0-metadata-1.2.0+metadata~dist"},
{"17.03.0-ce", "17.3.0-ce"}, // zero-padded fields
}
for _, tc := range cases {
v, err := NewVersion(tc[0])
if err != nil {
t.Fatalf("err: %s", err)
}
actual := v.String()
expected := tc[1]
if actual != expected {
t.Fatalf("expected: %s\nactual: %s", expected, actual)
}
if actual := v.Original(); actual != tc[0] {
t.Fatalf("expected original: %q\nactual: %q", tc[0], actual)
}
}
}