synapsecns/sanguine

package moduledetector_test

import (
    "github.com/Flaque/filet"
    "github.com/go-git/go-git/v5"
    copier "github.com/otiai10/copy"
    . "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/suite"
    "github.com/synapsecns/sanguine/core/testsuite"
    "io"
    "os"
    "strings"
    "testing"
)

// DetectorSuite defines the basic test suite.
type DetectorSuite struct {
    *testsuite.TestSuite
    // sourceRepo stores the source repository for the test suite.
    sourceRepo TestRepo
    // unsafeSourceRepo stores the source repository for the test suite.
    // it is called unsafe since it should not be used by tests
    unsafeSourceRepo TestRepo
    // unsafeHeadRef stores the head ref for the unsafe source repository.
    // this makes sure it hasn't been modified by a test
    unsafeHeadRef string
}

// TestRepo is a test repository.
type TestRepo struct {
    repo *git.Repository
    dir  string
}

// NewTestSuite creates a new test suite and performs some basic checks afterward.
// Every test suite in the synapse library should inherit from this suite and override where necessary.
func NewTestSuite(tb testing.TB) *DetectorSuite {
    tb.Helper()
    return &DetectorSuite{
        TestSuite: testsuite.NewTestSuite(tb),
    }
}

func (d *DetectorSuite) SetupSuite() {
    d.TestSuite.SetupSuite()

    d.unsafeSourceRepo.dir = filet.TmpDir(d.T(), "")
    var err error
    // clone the repo
    d.unsafeSourceRepo.repo, err = git.PlainClone(d.unsafeSourceRepo.dir, false, &git.CloneOptions{
        URL:      "https://github.com/xmlking/go-workspace",
        Progress: nullWriter{},
        Depth:    1,
    })
    Nil(d.T(), err, "could not clone source repo")

    // store the headref for integrity checking after tests
    headRef, err := d.unsafeSourceRepo.repo.Head()
    Nil(d.T(), err, "could not get source repo head ref")

    d.unsafeHeadRef = headRef.Hash().String()
}

func (d *DetectorSuite) SetupTest() {
    d.TestSuite.SetupTest()
    d.sourceRepo.dir = filet.TmpDir(d.T(), "")

    // copy the source repo to a new directory for testing
    // this saves us from having to clone the repo for every test
    err := copier.Copy(d.unsafeSourceRepo.dir, d.sourceRepo.dir)
    Nil(d.T(), err, "could not copy source repo")

    d.sourceRepo.repo, err = git.PlainOpen(d.sourceRepo.dir)
    Nil(d.T(), err, "could not open source repo")

    // unset all github env vars
    for _, osVar := range os.Environ() {
        splitVar := strings.Split(osVar, "=")
        key := splitVar[0]

        if strings.HasPrefix(key, "GITHUB_") {
            d.T().Setenv(key, "")
        }
    }
}

func (d *DetectorSuite) TearDownTest() {
    d.TestSuite.TearDownTest()

    // remove the test repo
    err := os.RemoveAll(d.sourceRepo.dir)
    if err != nil {
        d.T().Fatal(err)
    }

    // make sure there are no changes to the unsafe repo
    workTree, err := d.unsafeSourceRepo.repo.Worktree()
    Nil(d.T(), err, "could not get source repo working dir")

    // make sure nothings changed by seeing if any file is dirty
    status, err := workTree.Status()
    Nil(d.T(), err, "could not get source repo status")
    if !status.IsClean() {
        d.T().Fatal("unsafeSourceRepo repo has been modified, please use sourceRepo instead")
    }

    // make sure the head ref hasn't changed
    headRef, err := d.unsafeSourceRepo.repo.Head()
    Nil(d.T(), err, "could not get source repo head ref")
    if headRef.Hash().String() != d.unsafeHeadRef {
        d.T().Fatal("unsafeSourceRepo repo has been modified, please use sourceRepo instead")
    }
}

func (d *DetectorSuite) TearDownSuite() {
    err := os.RemoveAll(d.unsafeSourceRepo.dir)
    if err != nil {
        d.T().Fatal(err)
    }
}

func TestDetectorSuite(t *testing.T) {
    suite.Run(t, NewTestSuite(t))
}

// nullWriter writes no progress.
type nullWriter struct{}

// Write implements io.Writer and does nothing.
func (nullWriter) Write(p []byte) (n int, err error) {
    // Do Nothing
    return 0, nil
}

var _ io.Writer = nullWriter{}