kubernetes
/
kubectl
mirror of https://github.com/kubernetes/kubectl.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Create different internal error types

This commit is contained in:
Jingfang Liu 2018-02-20 10:41:26 -08:00
parent 53407951d6
commit a07208518f
10 changed files with 374 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
pkg/kinflate/internal/configmaperror.go Normal file
View File

@ -0,0 +1,28 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import "fmt"
type ConfigmapError struct {
ManifestFilepath string
ErrorMsg string
}
func (e ConfigmapError) Error() string {
return fmt.Sprintf("Manifest file [%s] encounters a configmap error: %s\n", e.ManifestFilepath, e.ErrorMsg)
}

24
pkg/kinflate/util/manifesterror_test.go → pkg/kinflate/internal/configmaperror_test.go
View File

@ -14,21 +14,25 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
package util
package internal
import (
"fmt"
"strings"
"testing"
)
func TestManifestError_Error(t *testing.T) {
func TestConfigmapError_Error(t *testing.T) {
filepath := "/path/to/Kube-manifest.yaml"
errorMsg := "Manifest not found"
expectedErrorMsg := fmt.Sprintf("Manifest File [%s]: %s\n", filepath, errorMsg)
me := ManifestError{ManifestFilepath: filepath, ErrorMsg: errorMsg}
if me.Error() != expectedErrorMsg {
t.Errorf("Incorrect ManifestError.Error() message\n")
t.Errorf(" Expected: %s\n", expectedErrorMsg)
t.Errorf(" Got: %s\n", me.Error())
errorMsg := "configmap name is missing"
me := ConfigmapError{ManifestFilepath: filepath, ErrorMsg: errorMsg}
if !strings.Contains(me.Error(), filepath) {
t.Errorf("Incorrect ConfigmapError.Error() message \n")
t.Errorf("Expected filepath %s, but unfound\n", filepath)
}
if !strings.Contains(me.Error(), errorMsg) {
t.Errorf("Incorrect ConfigmapError.Error() message \n")
t.Errorf("Expected errorMsg %s, but unfound\n", errorMsg)
}
}

57
pkg/kinflate/internal/manifesterror.go Normal file
View File

@ -0,0 +1,57 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"fmt"
)
// First pass to encapsulate fields for more informative error messages.
type ManifestError struct {
ManifestFilepath string
ErrorMsg string
}
func (me ManifestError) Error() string {
return fmt.Sprintf("Manifest File [%s]: %s\n", me.ManifestFilepath, me.ErrorMsg)
}
type ManifestErrors struct {
merrors []error
}
func (me *ManifestErrors) Error() string {
errormsg := ""
for _, e := range me.merrors {
errormsg += e.Error() + "\n"
}
return errormsg
}
func (me *ManifestErrors) Append(e error) {
me.merrors = append(me.merrors, e)
}
func (me *ManifestErrors) Get() []error {
return me.merrors
}
func (me *ManifestErrors) BatchAppend(e ManifestErrors) {
for _, err := range e.Get() {
me.merrors = append(me.merrors, err)
}
}

92
pkg/kinflate/internal/manifesterror_test.go Normal file
View File

@ -0,0 +1,92 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"fmt"
"strings"
"testing"
)
func TestManifestError_Error(t *testing.T) {
filepath := "/path/to/Kube-manifest.yaml"
errorMsg := "Manifest not found"
me := ManifestError{ManifestFilepath: filepath, ErrorMsg: errorMsg}
if !strings.Contains(me.Error(), filepath) {
t.Errorf("Incorrect ManifestError.Error() message \n")
t.Errorf("Expected filepath %s, but unfound\n", filepath)
}
if !strings.Contains(me.Error(), errorMsg) {
t.Errorf("Incorrect ManifestError.Error() message \n")
t.Errorf("Expected errorMsg %s, but unfound\n", errorMsg)
}
}
func TestManifestErrors_Error(t *testing.T) {
filepath := "/path/to/Kube-manifest.yaml"
me := ManifestError{ManifestFilepath: filepath, ErrorMsg: "Manifest not found"}
ce := ConfigmapError{ManifestFilepath: filepath, ErrorMsg: "can't find configmap name"}
pe := PatchError{ManifestFilepath: filepath, PatchFilepath: filepath, ErrorMsg: "can't find patch file"}
re := ResourceError{ManifestFilepath: filepath, ResourceFilepath: filepath, ErrorMsg: "can't find resource file"}
se := SecretError{ManifestFilepath: filepath, ErrorMsg: "can't find secret name"}
mes := ManifestErrors{merrors: []error{me, ce, pe, re, se}}
expectedErrorMsg := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n", me.Error(), ce.Error(), pe.Error(), re.Error(), se.Error())
if mes.Error() != expectedErrorMsg {
t.Errorf("Incorrect ManifestErrors.Error() message\n")
t.Errorf(" Expected: %s\n", expectedErrorMsg)
t.Errorf(" Got: %s\n", mes.Error())
}
}
func TestManifestErrors_Get(t *testing.T) {
ce := ConfigmapError{ManifestFilepath: "manifest/filepath", ErrorMsg: "can't find configmap name"}
mes := ManifestErrors{merrors: []error{ce}}
if len(mes.Get()) != 1 {
t.Errorf("Incorrect ManifestErrors.Get()\n")
t.Errorf(" Expected: %v\n", []error{ce})
t.Errorf(" Got: %s\n", mes.Get())
}
}
func TestManifestErrors_Append(t *testing.T) {
ce := ConfigmapError{ManifestFilepath: "manifest/filepath", ErrorMsg: "can't find configmap name"}
pe := PatchError{ManifestFilepath: "manifest/filepath", PatchFilepath: "patch/path", ErrorMsg: "can't find patch file"}
mes := ManifestErrors{merrors: []error{ce}}
mes.Append(pe)
if len(mes.Get()) != 2 {
t.Errorf("Incorrect ManifestErrors.Append()\n")
t.Errorf(" Expected: %d errors\n%v/n", 2, []error{ce, pe})
t.Errorf(" Got: %d errors\n%v\n", len(mes.Get()), mes.Get())
}
}
func TestManifestErrors_BatchAppend(t *testing.T) {
ce := ConfigmapError{ManifestFilepath: "manifest/filepath", ErrorMsg: "can't find configmap name"}
pe := PatchError{ManifestFilepath: "manifest/filepath", PatchFilepath: "patch/path", ErrorMsg: "can't find patch file"}
mes := ManifestErrors{merrors: []error{ce}}
me := ManifestErrors{merrors: []error{pe}}
mes.BatchAppend(me)
if len(mes.Get()) != 2 {
t.Errorf("Incorrect ManifestErrors.Append()\n")
t.Errorf(" Expected: %d errors\n%v/n", 2, []error{ce, pe})
t.Errorf(" Got: %d errors\n%v\n", len(mes.Get()), mes.Get())
}
}

31
pkg/kinflate/internal/patcherror.go Normal file
View File

@ -0,0 +1,31 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"fmt"
)
type PatchError struct {
ManifestFilepath string
PatchFilepath string
ErrorMsg string
}
func (e PatchError) Error() string {
return fmt.Sprintf("Manifest file [%s] encounters a patch error for [%s]: %s\n", e.ManifestFilepath, e.PatchFilepath, e.ErrorMsg)
}

41
pkg/kinflate/internal/patcherror_test.go Normal file
View File

@ -0,0 +1,41 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"strings"
"testing"
)
func TestPatchError_Error(t *testing.T) {
filepath := "/path/to/Kube-manifest.yaml"
patchfilepath := "/path/to/patch/patch.yaml"
errorMsg := "file not found"
me := PatchError{ManifestFilepath: filepath, PatchFilepath: patchfilepath, ErrorMsg: errorMsg}
if !strings.Contains(me.Error(), filepath) {
t.Errorf("Incorrect PatchError.Error() message \n")
t.Errorf("Expected filepath %s, but unfound\n", filepath)
}
if !strings.Contains(me.Error(), patchfilepath) {
t.Errorf("Incorrect PatchError.Error() message \n")
t.Errorf("Expected patchfilepath %s, but unfound\n", patchfilepath)
}
if !strings.Contains(me.Error(), errorMsg) {
t.Errorf("Incorrect PatchError.Error() message \n")
t.Errorf("Expected errorMsg %s, but unfound\n", errorMsg)
}
}

9
pkg/kinflate/util/manifesterror.go → pkg/kinflate/internal/resourceerror.go
View File

@ -14,16 +14,17 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
package util
package internal
import "fmt"
// First pass to encapsulate fields for more informative error messages.
type ManifestError struct {
type ResourceError struct {
ManifestFilepath string
ResourceFilepath string
ErrorMsg string
}
func (me ManifestError) Error() string {
return fmt.Sprintf("Manifest File [%s]: %s\n", me.ManifestFilepath, me.ErrorMsg)
func (e ResourceError) Error() string {
return fmt.Sprintf("Manifest file [%s] encounters a resource error for [%s]: %s\n", e.ManifestFilepath, e.ResourceFilepath, e.ErrorMsg)
}

41
pkg/kinflate/internal/resourceerror_test.go Normal file
View File

@ -0,0 +1,41 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"strings"
"testing"
)
func TestResourceError_Error(t *testing.T) {
filepath := "/path/to/Kube-manifest.yaml"
resourcefilepath := "/path/to/resource/deployment.yaml"
errorMsg := "file not found"
me := ResourceError{ManifestFilepath: filepath, ResourceFilepath: resourcefilepath, ErrorMsg: errorMsg}
if !strings.Contains(me.Error(), filepath) {
t.Errorf("Incorrect ResourceError.Error() message \n")
t.Errorf("Expected filepath %s, but unfound\n", filepath)
}
if !strings.Contains(me.Error(), resourcefilepath) {
t.Errorf("Incorrect ResourceError.Error() message \n")
t.Errorf("Expected resourcefilepath %s, but unfound\n", resourcefilepath)
}
if !strings.Contains(me.Error(), errorMsg) {
t.Errorf("Incorrect ResourceError.Error() message \n")
t.Errorf("Expected errorMsg %s, but unfound\n", errorMsg)
}
}

28
pkg/kinflate/internal/secreterror.go Normal file
View File

@ -0,0 +1,28 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import "fmt"
type SecretError struct {
ManifestFilepath string
ErrorMsg string
}
func (e SecretError) Error() string {
return fmt.Sprintf("Manifest file [%s] encounters a secret error: %s\n", e.ManifestFilepath, e.ErrorMsg)
}

37
pkg/kinflate/internal/secreterror_test.go Normal file
View File

@ -0,0 +1,37 @@
/*
Copyright 2018 The Kubernetes Authors.
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 internal
import (
"strings"
"testing"
)
func TestSecretError_Error(t *testing.T) {
filepath := "/path/to/secret.yaml"
errorMsg := "missing a command"
me := SecretError{ManifestFilepath: filepath, ErrorMsg: errorMsg}
if !strings.Contains(me.Error(), filepath) {
t.Errorf("Incorrect SecretError.Error() message \n")
t.Errorf("Expected filepath %s, but unfound\n", filepath)
}
if !strings.Contains(me.Error(), errorMsg) {
t.Errorf("Incorrect SecretError.Error() message \n")
t.Errorf("Expected errorMsg %s, but unfound\n", errorMsg)
}
}