issues-go/io_test.go

package issues

import (
	"os"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func Test_readPath_throws_not_found(t *testing.T) {
	_, err := readPath("doesntexist")
	assert.Error(t, err, "should never exist!")

	_, err2 := readPath("tests/asdfasdf")
	assert.Error(t, err2, "should never exist!")
}

func Test_readPath_succeeds(t *testing.T) {
	data, err := readPath("tests/bugs/test-1/description")
	if err != nil {
		assert.Fail(t, "function threw error, does tests/bugs/test-1 exist?")
	}
	assert.Equal(t, data, "test description\n")
}

func Test_IsIssue_success(t *testing.T) {
	val := IsIssue("tests/bugs/test-1")
	assert.True(t, val)
}

func Test_IsIssue_fail(t *testing.T) {
	val := IsIssue("tests/isnotabug")
	assert.False(t, val)
}

func Test_IsIssue_returns_false_on_error(t *testing.T) {
	val := IsIssue("willneverexist")
	assert.False(t, val)
}

func Test_IsIssueCollection_success(t *testing.T) {
	val := IsIssueCollection("tests/bugs/")
	assert.True(t, val)
}

func Test_IsIssueCollection_fail(t *testing.T) {
	val := IsIssueCollection("tests/")
	assert.False(t, val)
}

func Test_IsIssueCollection_returns_false_on_error(t *testing.T) {
	val := IsIssueCollection("willneverexist")
	assert.False(t, val)
}

func Test_WriteIssue_fails_on_existing(t *testing.T) {
	testIssue := Issue{
		Title: "",
		Path:  "tests/bugs/test-1",
	}

	_, err := WriteIssue(testIssue, false)
	assert.Error(t, err)
}

func Test_WriteIssue_fails_on_bad_path(t *testing.T) {
	testIssue := Issue{
		Title: "",
		Path:  "tests/cantexist/test",
	}

	_, err := WriteIssue(testIssue, false)
	assert.Error(t, err)
}

func Test_WriteIssue_creates_base_path(t *testing.T) {
	testIssue := Issue{Path: "tests/bugs/test-write1"}

	// clean up path
	err := os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)

	// run test
	result, err := WriteIssue(testIssue, false)
	assert.Nil(t, err)
	assert.True(t, result)

	// clean up path
	err = os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)
}

func Test_WriteIssue_creates_fields(t *testing.T) {
	testIssue := Issue{
		Path:        "tests/bugs/test-write2",
		Status:      Field{Path: "/status", Data: "test"},
		Description: Field{Path: "/description", Data: "test"},
	}

	// clean up path
	err := os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)

	// run test
	result, err := WriteIssue(testIssue, false)
	assert.Nil(t, err)
	assert.True(t, result)

	// clean up path
	err = os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)
}

func Test_WriteIssue_creates_variadic_fields(t *testing.T) {
	testIssue := Issue{
		Path: "tests/bugs/test-write3",
		Tags: VariadicField{
			Path: "/tags",
			Fields: []Field{
				{Path: "test1"},
				{Path: "test2"},
			},
		},
		Blockedby: VariadicField{
			Path: "/blockedby",
			Fields: []Field{
				{Path: "test1"},
				{Path: "test2"},
			},
		},
	}

	// clean up path
	err := os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)

	// run test
	result, err := WriteIssue(testIssue, false)
	assert.Nil(t, err)
	assert.True(t, result)

	// clean up path
	err = os.RemoveAll(testIssue.Path)
	assert.Nil(t, err)
}

func Test_WriteIssue_overwrites(t *testing.T) {
	testIssue := Issue{
		Path:        "tests/bugs/test-overwrite",
		Title:       "test overwrite",
		Status:      Field{Path: "/status", Data: "test"},
		Description: Field{Path: "/description", Data: "test"},
		Tags: VariadicField{
			Path: "/tags",
			Fields: []Field{
				{Path: "test1"},
				{Path: "test2"},
			},
		},
		Blockedby: VariadicField{
			Path: "/blockedby",
			Fields: []Field{
				{Path: "test1"},
				{Path: "test2"},
			},
		},
	}

	_, err := WriteIssue(testIssue, true)
	assert.Nil(t, err)
}

func Test_Generate_and_Read_Template(t *testing.T) {
	testPath := "tests/desc1"

	// clean up path
	err := os.RemoveAll(testPath)
	assert.Nil(t, err)

	err = GenerateTemplate(DescriptionTemplate, testPath)
	assert.Nil(t, err)

	lines, err := ReadTemplate(testPath)
	assert.Nil(t, err)
	assert.Equal(t, 1, len(lines))

	// clean up path
	err = os.RemoveAll(testPath)
	assert.Nil(t, err)
}

func Test_EditTemplate(t *testing.T) {
	testEditFunc := func(path string) error {
		d := []string{
			"title\n",
			"# ignore\n",
			"\n",
			"# ignore\n",
			"description\n",
			"# ignore\n",
			"# ignore\n",
			"# ignore\n",
		}
		send := ""
		for _, v := range d {
			send = send + v
		}
		err := os.WriteFile(path, []byte(send), 0755)
		time.Sleep(5 * time.Millisecond)
		return err
	}

	data, err := EditTemplate(DescriptionTemplate, testEditFunc)
	assert.Nil(t, err)
	assert.IsType(t, []string{}, data)
	assert.Equal(t, 4, len(data), data)
}