feat: Add IdentifierStartsWith

[anthony-treuillier-scality]

IdentifierStartsWith allows error comparison with a prefix. Useful when matching specific errors with HTTP Code in API handlers

Example: If e.Identifier: "3-2-1"

IdentifierStartsWith(e, "3-2") // return true
IdentifierStartsWith(e, "2-1") // return false

[g-carre]

could you add some tests with error Identifier = 31-22-12 and test with the following prefix:

• 3
• 31
• 31-2
• 31-22
• 31-22-1
• 31-22-12

[anthony-treuillier-scality]

For sure, I can, but what is the difference with these tests:

It("should return true when error's identifier starts with the prefix", func() {
	e1_1 := Wrap(ErrForbidden, WithIdentifier(1))
	e1_2 := Wrap(e1_1, WithIdentifier(2))
	e1_3 := Wrap(e1_2, WithIdentifier(3))
	Expect(IdentifierStartsWith(e1_3, "3")).To(BeTrue())
	Expect(IdentifierStartsWith(e1_3, "3-2")).To(BeTrue())
	Expect(IdentifierStartsWith(e1_3, "3-2-1")).To(BeTrue())
})

[g-carre]

I want to know if you expect false for 3, 31-2 and 31-21-1 Meaning ig you treat the prefix as a pure string or if the value in dash means something

[anthony-treuillier-scality]

I made some changes to catch edge cases

[ezekiel-alexrod]

Since Identifier is a slice of int32, we can do this:

func IdentifierStartsWith(err error, prefix ...uint32) bool {
        var e *Error

        if !errors.As(err, &e) {
                return false
        }

        if len(prefix) > len(e.Identifier) {
                return false
        }

        n := len(e.Identifier)
        for i, p := range prefix {
                if e.Identifier[n-1-i] != p {
                        return false
                }
        }

        return true
 }

[anthony-treuillier-scality]

I found another implementation based on string. Your solution should work, but it seems to me more complicated as we have to deal with the reverse order

[ezekiel-alexrod]

The tests have the same title

[anthony-treuillier-scality]

I will change this

[ezekiel-alexrod]

Same, we can deduplicate

[ezekiel-alexrod]

Maybe to explain the differences between Is() and IdentifierStartsWith()

 e := Wrap(Wrap(Wrap(Base, WithIdentifier(1)), WithIdentifier(2)), WithIdentifier(3))
 IdentifierStartsWith(e, 3, 2) // true — matches the most recent wraps (outermost)
 e.Is(parent)                  // matches an ancestor (innermost)

[g-carre]

Suggested change

	// IdentifierStartsWith checks if the error's identifier starts with the given prefix.
	// IdentifierStartsWith checks if the error's identifier string starts with the given prefix.