storage_test.go

package goldga

import (
	"bytes"
	"os"
	"path/filepath"

	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"github.com/spf13/afero"
)

type tempFs struct {
	afero.Fs

	path string
}

func newTempFs() *tempFs {
	fs := afero.NewOsFs()
	dir, err := afero.TempDir(fs, "", "goldga-test")
	Expect(err).NotTo(HaveOccurred())

	return &tempFs{
		Fs:   fs,
		path: dir,
	}
}

func (t *tempFs) Teardown() {
	Expect(os.RemoveAll(t.path)).To(Succeed())
}

var _ = Describe("SingleStorage", func() {
	var (
		storage *SingleStorage
		fs      *tempFs
	)

	expected := []byte("test")

	BeforeEach(func() {
		fs = newTempFs()
		storage = &SingleStorage{
			Path: filepath.Join(fs.path, "foo", "bar"),
			Fs:   fs,
		}
		Expect(afero.SafeWriteReader(fs, storage.Path, bytes.NewReader(expected))).To(Succeed())
	})

	AfterEach(func() {
		fs.Teardown()
	})

	Context("Read", func() {
		var (
			output []byte
			err    error
		)

		JustBeforeEach(func() {
			output, err = storage.Read()
		})

		It("should return the expected", func() {
			Expect(output).To(Equal(expected))
		})

		It("should not return error", func() {
			Expect(err).NotTo(HaveOccurred())
		})
	})

	Context("Write", func() {
		var err error
		input := []byte("bar")

		JustBeforeEach(func() {
			err = storage.Write(input)
		})

		testSuccess := func() {
			It("should not return error", func() {
				Expect(err).NotTo(HaveOccurred())
			})

			It("should write the file", func() {
				actual, err := afero.ReadFile(fs, storage.Path)
				Expect(err).NotTo(HaveOccurred())
				Expect(actual).To(Equal(input))
			})
		}

		When("file already exists", func() {
			testSuccess()
		})

		When("file not exist", func() {
			BeforeEach(func() {
				Expect(fs.Remove(storage.Path)).To(Succeed())
			})

			testSuccess()
		})
	})
})

var _ = Describe("SuiteStorage", func() {
	var (
		storage *SuiteStorage
		fs      *tempFs
	)

	BeforeEach(func() {
		fs = newTempFs()
		storage = &SuiteStorage{
			Path: filepath.Join(fs.path, "foo", "bar"),
			Name: "Suite test",
			Fs:   fs,
		}
	})

	AfterEach(func() {
		fs.Teardown()
	})

	writeFile := func(data string) {
		Expect(afero.SafeWriteReader(fs, storage.Path, bytes.NewReader([]byte(data)))).To(Succeed())
	}

	Context("Read", func() {
		var (
			output []byte
			err    error
		)

		JustBeforeEach(func() {
			output, err = storage.Read()
		})

		testNotFound := func() {
			It("should return nil", func() {
				Expect(output).To(BeNil())
			})

			It("should return not found error", func() {
				Expect(err).To(Equal(afero.ErrFileNotFound))
			})
		}

		When("file exists", func() {
			When("snapshot exist", func() {
				BeforeEach(func() {
					writeFile(`
[snapshots]
"Suite test" = "foo"`)
				})

				It("should return the content", func() {
					Expect(output).To(Equal([]byte("foo")))
				})

				It("should not return error", func() {
					Expect(err).NotTo(HaveOccurred())
				})
			})

			When("snapshot not exist", func() {
				BeforeEach(func() {
					writeFile(`[snapshots]`)
				})

				testNotFound()
			})
		})

		When("file not exist", func() {
			testNotFound()
		})
	})

	Context("Write", func() {
		var err error
		input := []byte("bar")

		JustBeforeEach(func() {
			err = storage.Write(input)
		})

		readFile := func() string {
			content, err := afero.ReadFile(fs, storage.Path)
			Expect(err).NotTo(HaveOccurred())

			return string(content)
		}

		When("file already exists", func() {
			BeforeEach(func() {
				writeFile(`
[snapshots]
A = "abc"
Z = "zzz"`)
			})

			It("should write the file", func() {
				Expect(readFile()).To(Equal(`# Generated by goldga. DO NOT EDIT.
[snapshots]
"A" = '''
abc'''
"Suite test" = '''
bar'''
"Z" = '''
zzz'''
`))
			})

			It("should not return error", func() {
				Expect(err).NotTo(HaveOccurred())
			})
		})

		When("file not exist", func() {
			It("should write the file", func() {
				Expect(readFile()).To(Equal(`# Generated by goldga. DO NOT EDIT.
[snapshots]
"Suite test" = '''
bar'''
`))
			})

			It("should not return error", func() {
				Expect(err).NotTo(HaveOccurred())
			})
		})
	})
})