205 lines
6.8 KiB
Go
205 lines
6.8 KiB
Go
package standard
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/onsi/ginkgo/v2"
|
|
"github.com/onsi/gomega"
|
|
|
|
"github.com/nicholas-fedor/shoutrrr/internal/failures"
|
|
)
|
|
|
|
func TestStandard(t *testing.T) {
|
|
gomega.RegisterFailHandler(ginkgo.Fail)
|
|
ginkgo.RunSpecs(t, "Shoutrrr Standard Suite")
|
|
}
|
|
|
|
var (
|
|
logger *Logger
|
|
builder *strings.Builder
|
|
stringLogger *log.Logger
|
|
)
|
|
|
|
var _ = ginkgo.Describe("the standard logging implementation", func() {
|
|
ginkgo.When("setlogger is called with nil", func() {
|
|
ginkgo.It("should provide the logging API without any errors", func() {
|
|
logger = &Logger{}
|
|
logger.SetLogger(nil)
|
|
logger.Log("discarded log message")
|
|
|
|
gomega.Expect(logger.logger).ToNot(gomega.BeNil())
|
|
})
|
|
})
|
|
ginkgo.When("setlogger is called with a proper logger", func() {
|
|
ginkgo.BeforeEach(func() {
|
|
logger = &Logger{}
|
|
builder = &strings.Builder{}
|
|
stringLogger = log.New(builder, "", 0)
|
|
})
|
|
ginkgo.When("when logger.Log is called", func() {
|
|
ginkgo.It("should log messages", func() {
|
|
logger.SetLogger(stringLogger)
|
|
logger.Log("foo")
|
|
logger.Log("bar")
|
|
|
|
gomega.Expect(builder.String()).To(gomega.Equal("foo\nbar\n"))
|
|
})
|
|
})
|
|
ginkgo.When("when logger.Logf is called", func() {
|
|
ginkgo.It("should log messages", func() {
|
|
logger.SetLogger(stringLogger)
|
|
logger.Logf("foo %d", 7)
|
|
|
|
gomega.Expect(builder.String()).To(gomega.Equal("foo 7\n"))
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
var _ = ginkgo.Describe("the standard template implementation", func() {
|
|
ginkgo.When("a template is being set from a file", func() {
|
|
ginkgo.It("should load the template without any errors", func() {
|
|
file, err := os.CreateTemp("", "")
|
|
if err != nil {
|
|
ginkgo.Skip(fmt.Sprintf("Could not create temp file: %s", err))
|
|
|
|
return
|
|
}
|
|
fileName := file.Name()
|
|
defer os.Remove(fileName)
|
|
|
|
_, err = io.WriteString(file, "template content")
|
|
if err != nil {
|
|
ginkgo.Skip(fmt.Sprintf("Could not write to temp file: %s", err))
|
|
|
|
return
|
|
}
|
|
|
|
templater := &Templater{}
|
|
err = templater.SetTemplateFile("foo", fileName)
|
|
gomega.Expect(err).ToNot(gomega.HaveOccurred())
|
|
})
|
|
})
|
|
ginkgo.When("a template is being set from a file that does not exist", func() {
|
|
ginkgo.It("should return an error", func() {
|
|
templater := &Templater{}
|
|
err := templater.SetTemplateFile("foo", "filename_that_should_not_exist")
|
|
gomega.Expect(err).To(gomega.HaveOccurred())
|
|
})
|
|
})
|
|
ginkgo.When("a template is being set with a badly formatted string", func() {
|
|
ginkgo.It("should return an error", func() {
|
|
templater := &Templater{}
|
|
err := templater.SetTemplateString("foo", "template {{ missing end tag")
|
|
gomega.Expect(err).To(gomega.HaveOccurred())
|
|
})
|
|
})
|
|
ginkgo.When("a template is being retrieved with a present ID", func() {
|
|
ginkgo.It("should return the corresponding template", func() {
|
|
templater := &Templater{}
|
|
err := templater.SetTemplateString("bar", "template body")
|
|
gomega.Expect(err).NotTo(gomega.HaveOccurred())
|
|
|
|
tpl, found := templater.GetTemplate("bar")
|
|
gomega.Expect(tpl).ToNot(gomega.BeNil())
|
|
gomega.Expect(found).To(gomega.BeTrue())
|
|
})
|
|
})
|
|
ginkgo.When("a template is being retrieved with an invalid ID", func() {
|
|
ginkgo.It("should return an error", func() {
|
|
templater := &Templater{}
|
|
err := templater.SetTemplateString("bar", "template body")
|
|
gomega.Expect(err).NotTo(gomega.HaveOccurred())
|
|
|
|
tpl, found := templater.GetTemplate("bad ID")
|
|
gomega.Expect(tpl).To(gomega.BeNil())
|
|
gomega.Expect(found).ToNot(gomega.BeTrue())
|
|
})
|
|
})
|
|
})
|
|
|
|
var _ = ginkgo.Describe("the standard enumless config implementation", func() {
|
|
ginkgo.When("it's enum method is called", func() {
|
|
ginkgo.It("should return an empty map", func() {
|
|
gomega.Expect((&EnumlessConfig{}).Enums()).To(gomega.BeEmpty())
|
|
})
|
|
})
|
|
})
|
|
|
|
var _ = ginkgo.Describe("the standard failure implementation", func() {
|
|
ginkgo.Describe("Failure function", func() {
|
|
ginkgo.When("called with FailParseURL", func() {
|
|
ginkgo.It("should return a failure with the correct message", func() {
|
|
err := errors.New("invalid URL")
|
|
failure := Failure(FailParseURL, err)
|
|
gomega.Expect(failure.ID()).To(gomega.Equal(FailParseURL))
|
|
gomega.Expect(failure.Error()).
|
|
To(gomega.ContainSubstring("error parsing Service URL"))
|
|
gomega.Expect(failure.Error()).To(gomega.ContainSubstring("invalid URL"))
|
|
})
|
|
})
|
|
ginkgo.When("called with FailUnknown", func() {
|
|
ginkgo.It("should return a failure with the unknown error message", func() {
|
|
err := errors.New("something went wrong")
|
|
failure := Failure(FailUnknown, err)
|
|
gomega.Expect(failure.ID()).To(gomega.Equal(FailUnknown))
|
|
gomega.Expect(failure.Error()).
|
|
To(gomega.ContainSubstring("an unknown error occurred"))
|
|
gomega.Expect(failure.Error()).To(gomega.ContainSubstring("something went wrong"))
|
|
})
|
|
})
|
|
ginkgo.When("called with an unrecognized FailureID", func() {
|
|
ginkgo.It("should fallback to the unknown error message", func() {
|
|
err := errors.New("unrecognized error")
|
|
failure := Failure(failures.FailureID(999), err) // Arbitrary unknown ID
|
|
gomega.Expect(failure.ID()).To(gomega.Equal(failures.FailureID(999)))
|
|
gomega.Expect(failure.Error()).
|
|
To(gomega.ContainSubstring("an unknown error occurred"))
|
|
gomega.Expect(failure.Error()).To(gomega.ContainSubstring("unrecognized error"))
|
|
})
|
|
})
|
|
ginkgo.When("called with additional arguments", func() {
|
|
ginkgo.It("should include formatted arguments in the error", func() {
|
|
err := errors.New("base error")
|
|
failure := Failure(FailParseURL, err, "extra info: %s", "details")
|
|
gomega.Expect(failure.Error()).
|
|
To(gomega.ContainSubstring("error parsing Service URL extra info: details"))
|
|
gomega.Expect(failure.Error()).To(gomega.ContainSubstring("base error"))
|
|
})
|
|
})
|
|
})
|
|
|
|
ginkgo.Describe("IsTestSetupFailure function", func() {
|
|
ginkgo.When("called with a FailTestSetup failure", func() {
|
|
ginkgo.It("should return true and the correct message", func() {
|
|
err := errors.New("setup issue")
|
|
failure := Failure(FailTestSetup, err)
|
|
msg, isSetupFailure := IsTestSetupFailure(failure)
|
|
gomega.Expect(isSetupFailure).To(gomega.BeTrue())
|
|
gomega.Expect(msg).To(gomega.ContainSubstring("test setup failed: setup issue"))
|
|
})
|
|
})
|
|
ginkgo.When("called with a different failure", func() {
|
|
ginkgo.It("should return false and an empty message", func() {
|
|
err := errors.New("parse issue")
|
|
failure := Failure(FailParseURL, err)
|
|
msg, isSetupFailure := IsTestSetupFailure(failure)
|
|
gomega.Expect(isSetupFailure).To(gomega.BeFalse())
|
|
gomega.Expect(msg).To(gomega.BeEmpty())
|
|
})
|
|
})
|
|
ginkgo.When("called with nil", func() {
|
|
ginkgo.It("should return false and an empty message", func() {
|
|
msg, isSetupFailure := IsTestSetupFailure(nil)
|
|
gomega.Expect(isSetupFailure).To(gomega.BeFalse())
|
|
gomega.Expect(msg).To(gomega.BeEmpty())
|
|
})
|
|
})
|
|
})
|
|
})
|