101 lines
3.1 KiB
Go
101 lines
3.1 KiB
Go
package provider
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
)
|
|
|
|
type recordedCall struct{ provider, op, result string }
|
|
|
|
type fakeRecorder struct{ calls []recordedCall }
|
|
|
|
func (f *fakeRecorder) ProviderRequest(provider, op, result string) {
|
|
f.calls = append(f.calls, recordedCall{provider, op, result})
|
|
}
|
|
|
|
// staticProvider returns canned values; only the classification of its
|
|
// errors matters here.
|
|
type staticProvider struct {
|
|
createErr, deleteErr, getErr, listErr error
|
|
}
|
|
|
|
func (s *staticProvider) Create(context.Context, CreateRequest) (string, error) {
|
|
return "id-1", s.createErr
|
|
}
|
|
func (s *staticProvider) Get(context.Context, string) (*Instance, error) {
|
|
return &Instance{ID: "id-1"}, s.getErr
|
|
}
|
|
func (s *staticProvider) Delete(context.Context, string) error { return s.deleteErr }
|
|
func (s *staticProvider) ListByTag(context.Context) ([]Instance, error) { return nil, s.listErr }
|
|
|
|
func TestWithMetrics_recordsClassifiedResults(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
inner *staticProvider
|
|
call func(p Provider) error
|
|
wantOp string
|
|
wantResult string
|
|
}{
|
|
{
|
|
name: "successful create is ok",
|
|
inner: &staticProvider{},
|
|
call: func(p Provider) error { _, err := p.Create(context.Background(), CreateRequest{}); return err },
|
|
wantOp: "create",
|
|
wantResult: "ok",
|
|
},
|
|
{
|
|
name: "get NotFound",
|
|
inner: &staticProvider{getErr: Wrap(ErrNotFound, "get", "x", "id-1", nil)},
|
|
call: func(p Provider) error { _, err := p.Get(context.Background(), "id-1"); return err },
|
|
wantOp: "get",
|
|
wantResult: "not_found",
|
|
},
|
|
{
|
|
name: "create quota",
|
|
inner: &staticProvider{createErr: Wrap(ErrQuotaExceeded, "create", "x", "", nil)},
|
|
call: func(p Provider) error { _, err := p.Create(context.Background(), CreateRequest{}); return err },
|
|
wantOp: "create",
|
|
wantResult: "quota_exceeded",
|
|
},
|
|
{
|
|
name: "delete permanent",
|
|
inner: &staticProvider{deleteErr: Wrap(ErrPermanent, "delete", "x", "id-1", nil)},
|
|
call: func(p Provider) error { return p.Delete(context.Background(), "id-1") },
|
|
wantOp: "delete",
|
|
wantResult: "permanent",
|
|
},
|
|
{
|
|
name: "unclassified list error is transient",
|
|
inner: &staticProvider{listErr: errors.New("connection reset")},
|
|
call: func(p Provider) error { _, err := p.ListByTag(context.Background()); return err },
|
|
wantOp: "list",
|
|
wantResult: "transient",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
rec := &fakeRecorder{}
|
|
p := WithMetrics("gcp-eu", tc.inner, rec)
|
|
|
|
callErr := tc.call(p)
|
|
|
|
if len(rec.calls) != 1 {
|
|
t.Fatalf("recorded %d calls, want 1", len(rec.calls))
|
|
}
|
|
want := recordedCall{provider: "gcp-eu", op: tc.wantOp, result: tc.wantResult}
|
|
if rec.calls[0] != want {
|
|
t.Errorf("recorded %+v, want %+v", rec.calls[0], want)
|
|
}
|
|
// The decorator must be transparent: errors pass through.
|
|
if (tc.wantResult == "ok") != (callErr == nil) {
|
|
t.Errorf("error passthrough broken: result %s but err %v", tc.wantResult, callErr)
|
|
}
|
|
})
|
|
}
|
|
}
|