Debian Codegraph @

internal/failures/failure_test.go

raw
1 package failures_test
2
3 import (
4 "errors"
5 "fmt"
6 "testing"
7
8 "github.com/onsi/ginkgo/v2"
9 "github.com/onsi/gomega"
10 "github.com/onsi/gomega/format"
11
12 "github.com/nicholas-fedor/shoutrrr/internal/failures"
13 "github.com/nicholas-fedor/shoutrrr/internal/testutils"
14 )
15
16 var _ = ginkgo.Describe("the failure package", func() {
17 // Common test fixtures
18 var (
19 testID failures.FailureID = 42 // Consistent ID for testing
20 testMessage = "test failure occurred" // Sample error message
21 wrappedErr = errors.New("underlying error") // Sample wrapped error
22 )
23
24 ginkgo.Describe("Wrap function", func() {
25 ginkgo.When("creating a basic failure", func() {
26 ginkgo.It("returns a failure with the provided message and ID", func() {
27 failure := failures.Wrap(testMessage, testID, nil)
28 gomega.Expect(failure.Error()).To(gomega.Equal(testMessage))
29 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
30 gomega.Expect(failure.Unwrap()).To(gomega.Succeed())
31 })
32 })
33
34 ginkgo.When("wrapping an existing error", func() {
35 ginkgo.It("combines the message and wrapped error", func() {
36 failure := failures.Wrap(testMessage, testID, wrappedErr)
37 expectedError := fmt.Sprintf("%s: %v", testMessage, wrappedErr)
38 gomega.Expect(failure.Error()).To(gomega.Equal(expectedError))
39 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
40 gomega.Expect(failure.Unwrap()).To(gomega.Equal(wrappedErr))
41 })
42 })
43
44 ginkgo.When("using formatted message with arguments", func() {
45 ginkgo.It("formats the message correctly", func() {
46 formatMessage := "test failure %d"
47 failure := failures.Wrap(formatMessage, testID, nil, 123)
48 gomega.Expect(failure.Error()).To(gomega.Equal("test failure 123"))
49 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
50 })
51 })
52 })
53
54 ginkgo.Describe("Failure interface methods", func() {
55 var failure failures.Failure
56
57 // Setup a failure with a wrapped error before each test
58 ginkgo.BeforeEach(func() {
59 failure = failures.Wrap(testMessage, testID, wrappedErr)
60 })
61
62 ginkgo.Describe("Error method", func() {
63 ginkgo.It("returns only the message when no wrapped error exists", func() {
64 failureNoWrap := failures.Wrap(testMessage, testID, nil)
65 gomega.Expect(failureNoWrap.Error()).To(gomega.Equal(testMessage))
66 })
67 ginkgo.It("combines message with wrapped error", func() {
68 expected := fmt.Sprintf("%s: %v", testMessage, wrappedErr)
69 gomega.Expect(failure.Error()).To(gomega.Equal(expected))
70 })
71 })
72
73 ginkgo.Describe("ID method", func() {
74 ginkgo.It("returns the assigned ID", func() {
75 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
76 })
77 })
78
79 ginkgo.Describe("Unwrap method", func() {
80 ginkgo.It("returns the wrapped error", func() {
81 gomega.Expect(failure.Unwrap()).To(gomega.Equal(wrappedErr))
82 })
83 ginkgo.It("returns nil when no wrapped error exists", func() {
84 failureNoWrap := failures.Wrap(testMessage, testID, nil)
85 gomega.Expect(failureNoWrap.Unwrap()).To(gomega.Succeed())
86 })
87 })
88
89 ginkgo.Describe("Is method", func() {
90 ginkgo.It("returns true for failures with the same ID", func() {
91 f1 := failures.Wrap("first", testID, nil)
92 f2 := failures.Wrap("second", testID, nil)
93 gomega.Expect(f1.Is(f2)).To(gomega.BeTrue())
94 gomega.Expect(f2.Is(f1)).To(gomega.BeTrue())
95 })
96 ginkgo.It("returns false for failures with different IDs", func() {
97 f1 := failures.Wrap("first", testID, nil)
98 f2 := failures.Wrap("second", testID+1, nil)
99 gomega.Expect(f1.Is(f2)).To(gomega.BeFalse())
100 gomega.Expect(f2.Is(f1)).To(gomega.BeFalse())
101 })
102 ginkgo.It("returns false when comparing with a non-failure error", func() {
103 f1 := failures.Wrap("first", testID, nil)
104 gomega.Expect(f1.Is(wrappedErr)).To(gomega.BeFalse())
105 })
106 })
107 })
108
109 ginkgo.Describe("edge cases", func() {
110 ginkgo.When("wrapping with an empty message", func() {
111 ginkgo.It("handles an empty message gracefully", func() {
112 failure := failures.Wrap("", testID, wrappedErr)
113 gomega.Expect(failure.Error()).To(gomega.Equal(": " + wrappedErr.Error()))
114 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
115 gomega.Expect(failure.Unwrap()).To(gomega.Equal(wrappedErr))
116 })
117 })
118
119 ginkgo.When("wrapping with nil error and no args", func() {
120 ginkgo.It("returns a valid failure with just message and ID", func() {
121 failure := failures.Wrap(testMessage, testID, nil)
122 gomega.Expect(failure.Error()).To(gomega.Equal(testMessage))
123 gomega.Expect(failure.ID()).To(gomega.Equal(testID))
124 gomega.Expect(failure.Unwrap()).To(gomega.Succeed())
125 })
126 })
127
128 ginkgo.When("using multiple wrapped failures", func() {
129 ginkgo.It("correctly chains and unwraps multiple errors", func() {
130 innerErr := errors.New("inner error")
131 middleErr := failures.Wrap("middle", testID+1, innerErr)
132 outerErr := failures.Wrap("outer", testID, middleErr)
133 gomega.Expect(outerErr.Error()).To(gomega.Equal("outer: middle: inner error"))
134 gomega.Expect(outerErr.ID()).To(gomega.Equal(testID))
135 gomega.Expect(outerErr.Unwrap()).To(gomega.Equal(middleErr))
136 gomega.Expect(middleErr.Unwrap()).To(gomega.Equal(innerErr))
137 })
138 })
139 })
140
141 ginkgo.Describe("integration-like scenarios", func() {
142 ginkgo.It("works with standard error wrapping utilities", func() {
143 innerErr := errors.New("inner error")
144 failure := failures.Wrap("wrapped failure", testID, innerErr)
145 gomega.Expect(errors.Is(failure, innerErr)).To(gomega.BeTrue()) // Matches wrapped error
146 gomega.Expect(errors.Unwrap(failure)).To(gomega.Equal(innerErr))
147 })
148
149 ginkgo.It("handles fmt.Errorf wrapping", func() {
150 failure := failures.Wrap("failure", testID, nil)
151 wrapped := fmt.Errorf("additional context: %w", failure)
152 gomega.Expect(wrapped.Error()).To(gomega.Equal("additional context: failure"))
153 gomega.Expect(errors.Unwrap(wrapped)).To(gomega.Equal(failure))
154 })
155 })
156
157 ginkgo.Describe("testutils integration", func() {
158 ginkgo.It("can use TestLogger for logging failures", func() {
159 // Demonstrate compatibility with testutils logger
160 failure := failures.Wrap("logged failure", testID, nil)
161 logger := testutils.TestLogger()
162 logger.Printf("Error occurred: %v", failure)
163 // No assertion needed; ensures no panic during logging
164 })
165 })
166 })
167
168 // TestFailures runs the Ginkgo test suite for the failures package.
169 func TestFailures(t *testing.T) {
170 t.Parallel()
171
172 format.CharactersAroundMismatchToInclude = 20 // Show more context in failure output
173
174 gomega.RegisterFailHandler(ginkgo.Fail)
175 ginkgo.RunSpecs(t, "Failure Suite")
176 }