Skip to content

Commit

Permalink
switch to oops
Browse files Browse the repository at this point in the history
  • Loading branch information
@mscno
mscno committed Mar 23, 2024
1 parent e87c7a4 commit d5642ec
Show file tree
Hide file tree
Showing 35 changed files with 440 additions and 1,619 deletions.
39 changes: 10 additions & 29 deletions already_exists.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,52 +3,33 @@ package zerrors
import (
"errors"
"fmt"
"github.com/samber/oops"
)

var (
_ AlreadyExists = (*AlreadyExistsError)(nil)
_ Error = (*AlreadyExistsError)(nil)
)

const AlreadyExistsId = "AlreadyExists"

type AlreadyExists interface {
error
IsAlreadyExists()
}

type AlreadyExistsError struct {
*Zerror
}
const ErrAlreadyExists = "already exists"

func ThrowAlreadyExists(action, kind, name string) error {
message := fmt.Sprintf("cannot %s '%s' of kind '%s'", action, name, kind)
return &AlreadyExistsError{CreateZerror(nil, AlreadyExistsId, message)}
return oops.Code(ErrAlreadyExists).Errorf(message)
}

func ThrowAlreadyExistsr(action, kind, name, reason string) error {
message := fmt.Sprintf("cannot %s '%s' of kind '%s': %s", action, name, kind, reason)
return &AlreadyExistsError{CreateZerror(nil, AlreadyExistsId, message)}
}

func ToAlreadyExists(parent error, id string, message string) error {
return &AlreadyExistsError{CreateZerror(parent, id, message)}
return oops.Code(ErrAlreadyExists).Errorf(message)
}

func ToAlreadyExistsf(parent error, id string, format string, a ...interface{}) error {
return ToAlreadyExists(parent, id, fmt.Sprintf(format, a...))
func AlreadyExists(format string, a ...interface{}) error {
return oops.Code(ErrAlreadyExists).Errorf(format, a...)
}

func (err *AlreadyExistsError) IsAlreadyExists() {}

func (err *AlreadyExistsError) Is(target error) bool {
return IsAlreadyExists(target)
func ToAlreadyExists(parent error, format string, a ...interface{}) error {
return oops.Code(ErrAlreadyExists).Wrapf(parent, format, a...)
}

func IsAlreadyExists(err error) bool {
var possibleError *AlreadyExistsError
var possibleError oops.OopsError
if errors.As(err, &possibleError) {
return true
return possibleError.Code() == ErrAlreadyExists
}
return false
}
97 changes: 16 additions & 81 deletions already_exists_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,106 +2,41 @@ package zerrors

import (
"errors"
"fmt"
"github.com/samber/oops"
"testing"

"github.com/stretchr/testify/assert"
)

func TestAlreadyExistsError(t *testing.T) {
var err interface{}
err = new(AlreadyExistsError)
_, ok := err.(AlreadyExists)
assert.True(t, ok)
}

func TestToAlreadyExistsf(t *testing.T) {
err := ToAlreadyExistsf(nil, "id", "msg")
_, ok := err.(*AlreadyExistsError)
assert.True(t, ok)
}

func TestIsAlreadyExists(t *testing.T) {
err := ToAlreadyExists(nil, "id", "msg")
func TestToAlreadyExistsOnNil(t *testing.T) {
err := ToAlreadyExists(nil, "id")
ok := IsAlreadyExists(err)
assert.True(t, ok)

ok = errors.Is(err, &AlreadyExistsError{})
assert.True(t, ok)

var e *AlreadyExistsError
ok = errors.As(err, &e)
assert.True(t, ok)

err = errors.New("I am found!")
ok = IsAlreadyExists(err)
assert.False(t, ok)
assert.Equal(t, err, nil)

ok = errors.Is(err, &AlreadyExistsError{})
assert.False(t, ok)
}

func TestFindWrappedAlreadyExists(t *testing.T) {
err := ToAlreadyExists(nil, "id", "msg")
ok := IsAlreadyExists(err)
assert.True(t, ok)

err = fmt.Errorf("wrapped %w", err)
ok = IsAlreadyExists(err)
assert.True(t, ok)

ok = errors.Is(err, &AlreadyExistsError{})
assert.True(t, ok)
func TestToAlreadyExists(t *testing.T) {
err := ToAlreadyExists(errors.New("not domain"), "id")
assert.True(t, IsAlreadyExists(err))

var e *AlreadyExistsError
ok = errors.As(err, &e)
var e oops.OopsError
ok := errors.As(err, &e)
assert.True(t, ok)

assert.Equal(t, ErrAlreadyExists, e.Code())
}

func TestAlreadyExistsWithRootCause(t *testing.T) {
err := ToAlreadyExists(fmt.Errorf("not domain"), "id", "no wrap message")
func TestIsAlreadyExistsOnNonDomain(t *testing.T) {
err := errors.New("I am found!")
ok := IsAlreadyExists(err)
assert.True(t, ok)

ok = errors.Is(err, &AlreadyExistsError{})
assert.True(t, ok)

var asDomain *AlreadyExistsError
ok = errors.As(err, &asDomain)
assert.True(t, ok)

if asDomain.Zerror.Parent == nil {
t.Fatal("underlying cause was not preserved")
}

assert.Equal(t, "not domain", asDomain.Zerror.Parent.Error())

assert.Equalf(t, "id", asDomain.Zerror.ID, "ID is not equal")
assert.Equalf(t, "no wrap message", asDomain.Zerror.Message, "Message is not equal")

msg := "ID=id Message=no wrap message Parent=(not domain)"
assert.Equal(t, msg, err.Error())
assert.False(t, ok)

}

func TestWrappingAnotherAlreadyExistsError(t *testing.T) {
err := ToAlreadyExists(nil, "id1", "msg")
func TestThrowAlreadyExists(t *testing.T) {
err := ThrowAlreadyExists("create", "user", "sam")
ok := IsAlreadyExists(err)
assert.True(t, ok)

err = ToAlreadyExists(err, "id2", "msg")
ok = IsAlreadyExists(err)
assert.True(t, ok)

ok = errors.Is(err, &AlreadyExistsError{})
assert.True(t, ok)

var e *AlreadyExistsError
ok = errors.As(err, &e)
assert.True(t, ok)
assert.Equal(t, "id2", e.Zerror.ID)

msg := "ID=id2 Message=msg Parent=(ID=id1 Message=msg)"
assert.Equal(t, msg, err.Error())
assert.Equal(t, err.Error(), "cannot create 'sam' of kind 'user'")
}
39 changes: 10 additions & 29 deletions deadline_exceeded.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,52 +3,33 @@ package zerrors
import (
"errors"
"fmt"
"github.com/samber/oops"
)

var (
_ DeadlineExceeded = (*DeadlineExceededError)(nil)
_ Error = (*DeadlineExceededError)(nil)
)

const DeadlineExceededId = "DeadlineExceeded"

type DeadlineExceeded interface {
error
IsDeadlineExceeded()
}

type DeadlineExceededError struct {
*Zerror
}
const ErrDeadlineExceeded = "deadline exceeded"

func ThrowDeadlineExceeded(action, kind, name string) error {
message := fmt.Sprintf("cannot %s '%s' of kind '%s'", action, name, kind)
return &DeadlineExceededError{CreateZerror(nil, DeadlineExceededId, message)}
return oops.Code(ErrDeadlineExceeded).Errorf(message)
}

func ThrowDeadlineExceededr(action, kind, name, reason string) error {
message := fmt.Sprintf("cannot %s '%s' of kind '%s': %s", action, name, kind, reason)
return &DeadlineExceededError{CreateZerror(nil, DeadlineExceededId, message)}
}

func ToDeadlineExceeded(parent error, id string, message string) error {
return &DeadlineExceededError{CreateZerror(parent, id, message)}
return oops.Code(ErrDeadlineExceeded).Errorf(message)
}

func ToDeadlineExceededf(parent error, id string, format string, a ...interface{}) error {
return ToDeadlineExceeded(parent, id, fmt.Sprintf(format, a...))
func DeadlineExceeded(format string, a ...interface{}) error {
return oops.Code(ErrDeadlineExceeded).Errorf(format, a...)
}

func (err *DeadlineExceededError) IsDeadlineExceeded() {}

func (err *DeadlineExceededError) Is(target error) bool {
return IsDeadlineExceeded(target)
func ToDeadlineExceeded(parent error, format string, a ...interface{}) error {
return oops.Code(ErrDeadlineExceeded).Wrapf(parent, format, a...)
}

func IsDeadlineExceeded(err error) bool {
var possibleError *DeadlineExceededError
var possibleError oops.OopsError
if errors.As(err, &possibleError) {
return true
return possibleError.Code() == ErrDeadlineExceeded
}
return false
}
97 changes: 16 additions & 81 deletions deadline_exceeded_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,106 +2,41 @@ package zerrors

import (
"errors"
"fmt"
"github.com/samber/oops"
"testing"

"github.com/stretchr/testify/assert"
)

func TestDeadlineExceededError(t *testing.T) {
var err interface{}
err = new(DeadlineExceededError)
_, ok := err.(DeadlineExceeded)
assert.True(t, ok)
}

func TestToDeadlineExceededf(t *testing.T) {
err := ToDeadlineExceededf(nil, "id", "msg")
_, ok := err.(*DeadlineExceededError)
assert.True(t, ok)
}

func TestIsDeadlineExceeded(t *testing.T) {
err := ToDeadlineExceeded(nil, "id", "msg")
func TestToDeadlineExceededOnNil(t *testing.T) {
err := ToDeadlineExceeded(nil, "id")
ok := IsDeadlineExceeded(err)
assert.True(t, ok)

ok = errors.Is(err, &DeadlineExceededError{})
assert.True(t, ok)

var e *DeadlineExceededError
ok = errors.As(err, &e)
assert.True(t, ok)

err = errors.New("I am found!")
ok = IsDeadlineExceeded(err)
assert.False(t, ok)
assert.Equal(t, err, nil)

ok = errors.Is(err, &DeadlineExceededError{})
assert.False(t, ok)
}

func TestFindWrappedDeadlineExceeded(t *testing.T) {
err := ToDeadlineExceeded(nil, "id", "msg")
ok := IsDeadlineExceeded(err)
assert.True(t, ok)

err = fmt.Errorf("wrapped %w", err)
ok = IsDeadlineExceeded(err)
assert.True(t, ok)

ok = errors.Is(err, &DeadlineExceededError{})
assert.True(t, ok)
func TestToDeadlineExceeded(t *testing.T) {
err := ToDeadlineExceeded(errors.New("not domain"), "id")
assert.True(t, IsDeadlineExceeded(err))

var e *DeadlineExceededError
ok = errors.As(err, &e)
var e oops.OopsError
ok := errors.As(err, &e)
assert.True(t, ok)

assert.Equal(t, ErrDeadlineExceeded, e.Code())
}

func TestDeadlineExceededWithRootCause(t *testing.T) {
err := ToDeadlineExceeded(fmt.Errorf("not domain"), "id", "no wrap message")
func TestIsDeadlineExceededOnNonDomain(t *testing.T) {
err := errors.New("I am found!")
ok := IsDeadlineExceeded(err)
assert.True(t, ok)

ok = errors.Is(err, &DeadlineExceededError{})
assert.True(t, ok)

var asDomain *DeadlineExceededError
ok = errors.As(err, &asDomain)
assert.True(t, ok)

if asDomain.Zerror.Parent == nil {
t.Fatal("underlying cause was not preserved")
}

assert.Equal(t, "not domain", asDomain.Zerror.Parent.Error())

assert.Equalf(t, "id", asDomain.Zerror.ID, "ID is not equal")
assert.Equalf(t, "no wrap message", asDomain.Zerror.Message, "Message is not equal")

msg := "ID=id Message=no wrap message Parent=(not domain)"
assert.Equal(t, msg, err.Error())
assert.False(t, ok)

}

func TestWrappingAnotherDeadlineExceededError(t *testing.T) {
err := ToDeadlineExceeded(nil, "id1", "msg")
func TestThrowDeadlineExceeded(t *testing.T) {
err := ThrowDeadlineExceeded("create", "user", "sam")
ok := IsDeadlineExceeded(err)
assert.True(t, ok)

err = ToDeadlineExceeded(err, "id2", "msg")
ok = IsDeadlineExceeded(err)
assert.True(t, ok)

ok = errors.Is(err, &DeadlineExceededError{})
assert.True(t, ok)

var e *DeadlineExceededError
ok = errors.As(err, &e)
assert.True(t, ok)
assert.Equal(t, "id2", e.Zerror.ID)

msg := "ID=id2 Message=msg Parent=(ID=id1 Message=msg)"
assert.Equal(t, msg, err.Error())
assert.Equal(t, err.Error(), "cannot create 'sam' of kind 'user'")
}
Loading

0 comments on commit d5642ec

Please sign in to comment.