issues-go/bug_test.go

package buggo

import (
	"testing"

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

func Test_Bug_New(t *testing.T) {
	testBug := Bug{
		Title:       "test 1",
		Description: Field{Data: "test description\n", Path: "/description"},
		Status:      Field{Data: "open:test\n", Path: "/status"},
		Path:        "tests/bugs/test-1",

		Tags: VariadicField{
			Path: "/tags", Fields: []Field{
				{Path: "tag1"},
				{Path: "tag2"},
			},
		},
		Blockedby: VariadicField{
			Path: "/blockedby", Fields: []Field{
				{Path: "blocker1"},
				{Path: "blocker2"},
			},
		},
	}

	bug, _ := Bug.New(Bug{}, testBug.Title, testBug.Status, testBug.Tags, testBug.Blockedby, testBug.Path)

	assert.Equal(t, testBug.Title, bug.Title)
	assert.Equal(t, testBug.Status, bug.Status)
	assert.Equal(t, testBug.Tags, bug.Tags)
	assert.Equal(t, testBug.Blockedby, bug.Blockedby)
	assert.Equal(t, testBug.Path, bug.Path)
}
func Test_Bug_NewFromPath_err_bad_path(t *testing.T) {
	testBug := Bug{}
	bug, err := Bug.NewFromPath(testBug, "doesntexist")

	assert.Error(t, err)
	assert.Equal(t, testBug, bug)
}

func Test_Bug_NewFromPath_success(t *testing.T) {
	testBug := Bug{
		Title:       "test 1",
		Description: Field{Data: "test description\n", Path: "/description"},
		Status:      Field{Data: "open:test\n", Path: "/status"},
		Path:        "tests/bugs/test-1",

		Tags: VariadicField{
			Path: "/tags", Fields: []Field{
				{Path: "tag1"},
				{Path: "tag2"},
			},
		},
		Blockedby: VariadicField{
			Path: "/blockedby", Fields: []Field{
				{Path: "blocker1"},
				{Path: "blocker2"},
			},
		},
	}

	bug, err := Bug.NewFromPath(Bug{}, "tests/bugs/test-1")
	if err != nil {
		assert.Fail(t, "should not err")
	}

	assert.Equal(t, testBug.Title, bug.Title)
	assert.Equal(t, testBug.Description, bug.Description)
	assert.Equal(t, testBug.Status, bug.Status)
	assert.Equal(t, testBug.Tags, bug.Tags)
	assert.Equal(t, testBug.Blockedby, bug.Blockedby)
	assert.Equal(t, testBug.Path, bug.Path)
}

func Test_Field_New(t *testing.T) {
	var testF = Field{Path: "test1", Data: "test1"}

	f := Field.New(Field{}, testF.Path, testF.Data)

	assert.Equal(t, testF, f)
}

func Test_VariadicField_New(t *testing.T) {
	var testVF = VariadicField{Path: "testing", Fields: []Field{{Path: "test"}}}
	vf := VariadicField.New(VariadicField{}, testVF.Fields, testVF.Path)

	assert.Equal(t, testVF, vf)
}

func Test_VariadicField_NewFromPath_fails(t *testing.T) {
	_, err := VariadicField.NewFromPath(VariadicField{Path: "/tags"}, "dosentexist")
	assert.Error(t, err)
}

func Test_VariadicField_NewFromPath_no_tags_dir(t *testing.T) {
	_, err := VariadicField.NewFromPath(VariadicField{Path: "/tags"}, "tests/bugs/test-2")
	assert.Error(t, err, "should not find tags")
}

func Test_VariadicField_NewFromPath_no_tags_in_dir(t *testing.T) {
	vf, err := VariadicField.NewFromPath(VariadicField{Path: "/tags"}, "tests/bugs/test-3")
	if err != nil {
		assert.Fail(t, "should not throw error")
	}
	assert.Equal(t, len(vf.Fields), 0)
}

func Test_VariadicField_NewFromPath_skip_dotfile(t *testing.T) {
	vf, err := VariadicField.NewFromPath(VariadicField{Path: "/tags"}, "tests/bugs/test-4")
	if err != nil {
		assert.Fail(t, "should not throw error")
	}
	assert.Equal(t, len(vf.Fields), 2)
}

func Test_VariadicField_NewFromPath_success(t *testing.T) {
	vf, err := VariadicField.NewFromPath(VariadicField{Path: "/tags"}, "tests/bugs/test-1")
	if err != nil {
		assert.Fail(t, "should not throw error")
	}
	assert.Equal(t, len(vf.Fields), 2)
}

func Test_parsePathToHuman(t *testing.T) {
	testPath := "test-dir/test-1--content"
	testParse := "test 1-content"
	parseResult := parsePathToHuman(testPath)

	assert.Equal(t, testParse, parseResult)
}

func Test_parseHumanToPath(t *testing.T) {
	testHuman := "test 1-content"
	testParse := "test-1--content"
	parseResult := parseHumanToPath(testHuman)

	assert.Equal(t, testParse, parseResult)
}