forked from TrueCloudLab/distribution
5abfc91021
To provide a single package with v2 API definitions, the locked down portions of the API have been merged into a single package. References to exported items will appear as v2.XXX, indicating their origin. The definitions in this package will soon be locked down for change, acceppting only additions that will not change protocol behavior.
165 lines
4.5 KiB
Go
165 lines
4.5 KiB
Go
package v2
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/docker/docker-registry/digest"
|
|
)
|
|
|
|
// TestErrorCodes ensures that error code format, mappings and
|
|
// marshaling/unmarshaling. round trips are stable.
|
|
func TestErrorCodes(t *testing.T) {
|
|
for _, desc := range ErrorDescriptors {
|
|
if desc.Code.String() != desc.Value {
|
|
t.Fatalf("error code string incorrect: %q != %q", desc.Code.String(), desc.Value)
|
|
}
|
|
|
|
if desc.Code.Message() != desc.Message {
|
|
t.Fatalf("incorrect message for error code %v: %q != %q", desc.Code, desc.Code.Message(), desc.Message)
|
|
}
|
|
|
|
// Serialize the error code using the json library to ensure that we
|
|
// get a string and it works round trip.
|
|
p, err := json.Marshal(desc.Code)
|
|
|
|
if err != nil {
|
|
t.Fatalf("error marshaling error code %v: %v", desc.Code, err)
|
|
}
|
|
|
|
if len(p) <= 0 {
|
|
t.Fatalf("expected content in marshaled before for error code %v", desc.Code)
|
|
}
|
|
|
|
// First, unmarshal to interface and ensure we have a string.
|
|
var ecUnspecified interface{}
|
|
if err := json.Unmarshal(p, &ecUnspecified); err != nil {
|
|
t.Fatalf("error unmarshaling error code %v: %v", desc.Code, err)
|
|
}
|
|
|
|
if _, ok := ecUnspecified.(string); !ok {
|
|
t.Fatalf("expected a string for error code %v on unmarshal got a %T", desc.Code, ecUnspecified)
|
|
}
|
|
|
|
// Now, unmarshal with the error code type and ensure they are equal
|
|
var ecUnmarshaled ErrorCode
|
|
if err := json.Unmarshal(p, &ecUnmarshaled); err != nil {
|
|
t.Fatalf("error unmarshaling error code %v: %v", desc.Code, err)
|
|
}
|
|
|
|
if ecUnmarshaled != desc.Code {
|
|
t.Fatalf("unexpected error code during error code marshal/unmarshal: %v != %v", ecUnmarshaled, desc.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestErrorsManagement does a quick check of the Errors type to ensure that
|
|
// members are properly pushed and marshaled.
|
|
func TestErrorsManagement(t *testing.T) {
|
|
var errs Errors
|
|
|
|
errs.Push(ErrorCodeDigestInvalid)
|
|
errs.Push(ErrorCodeBlobUnknown,
|
|
map[string]digest.Digest{"digest": "sometestblobsumdoesntmatter"})
|
|
|
|
p, err := json.Marshal(errs)
|
|
|
|
if err != nil {
|
|
t.Fatalf("error marashaling errors: %v", err)
|
|
}
|
|
|
|
expectedJSON := "{\"errors\":[{\"code\":\"DIGEST_INVALID\",\"message\":\"provided digest did not match uploaded content\"},{\"code\":\"BLOB_UNKNOWN\",\"message\":\"blob unknown to registry\",\"detail\":{\"digest\":\"sometestblobsumdoesntmatter\"}}]}"
|
|
|
|
if string(p) != expectedJSON {
|
|
t.Fatalf("unexpected json: %q != %q", string(p), expectedJSON)
|
|
}
|
|
|
|
errs.Clear()
|
|
errs.Push(ErrorCodeUnknown)
|
|
expectedJSON = "{\"errors\":[{\"code\":\"UNKNOWN\",\"message\":\"unknown error\"}]}"
|
|
p, err = json.Marshal(errs)
|
|
|
|
if err != nil {
|
|
t.Fatalf("error marashaling errors: %v", err)
|
|
}
|
|
|
|
if string(p) != expectedJSON {
|
|
t.Fatalf("unexpected json: %q != %q", string(p), expectedJSON)
|
|
}
|
|
}
|
|
|
|
// TestMarshalUnmarshal ensures that api errors can round trip through json
|
|
// without losing information.
|
|
func TestMarshalUnmarshal(t *testing.T) {
|
|
|
|
var errors Errors
|
|
|
|
for _, testcase := range []struct {
|
|
description string
|
|
err Error
|
|
}{
|
|
{
|
|
description: "unknown error",
|
|
err: Error{
|
|
|
|
Code: ErrorCodeUnknown,
|
|
Message: ErrorCodeUnknown.Descriptor().Message,
|
|
},
|
|
},
|
|
{
|
|
description: "unknown manifest",
|
|
err: Error{
|
|
Code: ErrorCodeManifestUnknown,
|
|
Message: ErrorCodeManifestUnknown.Descriptor().Message,
|
|
},
|
|
},
|
|
{
|
|
description: "unknown manifest",
|
|
err: Error{
|
|
Code: ErrorCodeBlobUnknown,
|
|
Message: ErrorCodeBlobUnknown.Descriptor().Message,
|
|
Detail: map[string]interface{}{"digest": "asdfqwerqwerqwerqwer"},
|
|
},
|
|
},
|
|
} {
|
|
fatalf := func(format string, args ...interface{}) {
|
|
t.Fatalf(testcase.description+": "+format, args...)
|
|
}
|
|
|
|
unexpectedErr := func(err error) {
|
|
fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
p, err := json.Marshal(testcase.err)
|
|
if err != nil {
|
|
unexpectedErr(err)
|
|
}
|
|
|
|
var unmarshaled Error
|
|
if err := json.Unmarshal(p, &unmarshaled); err != nil {
|
|
unexpectedErr(err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(unmarshaled, testcase.err) {
|
|
fatalf("errors not equal after round trip: %#v != %#v", unmarshaled, testcase.err)
|
|
}
|
|
|
|
// Roll everything up into an error response envelope.
|
|
errors.PushErr(testcase.err)
|
|
}
|
|
|
|
p, err := json.Marshal(errors)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error marshaling error envelope: %v", err)
|
|
}
|
|
|
|
var unmarshaled Errors
|
|
if err := json.Unmarshal(p, &unmarshaled); err != nil {
|
|
t.Fatalf("unexpected error unmarshaling error envelope: %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(unmarshaled, errors) {
|
|
t.Fatalf("errors not equal after round trip: %#v != %#v", unmarshaled, errors)
|
|
}
|
|
}
|