issues-go/issue_test.go

package issues

import (
	"testing"

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

func Test_Issue_New(t *testing.T) {
	// Custom title
	customTitleIssue := Issue{
		Title:       "custom-title",
		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"},
			},
		},
	}
	autoTitleIssue := Issue{
		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"},
			},
		},
	}

	ctIssue, _ := Issue.New(Issue{}, customTitleIssue.Title, customTitleIssue.Description,
		customTitleIssue.Status, customTitleIssue.Tags, customTitleIssue.Blockedby, customTitleIssue.Path)

	assert.Equal(t, customTitleIssue.Title, ctIssue.Title)
	assert.Equal(t, customTitleIssue.Status, ctIssue.Status)
	assert.Equal(t, customTitleIssue.Tags, ctIssue.Tags)
	assert.Equal(t, customTitleIssue.Blockedby, ctIssue.Blockedby)
	assert.Equal(t, customTitleIssue.Path, ctIssue.Path)

	atIssue, _ := Issue.New(Issue{}, "", customTitleIssue.Description,
		customTitleIssue.Status, customTitleIssue.Tags, customTitleIssue.Blockedby, customTitleIssue.Path)

	assert.Equal(t, parsePathToHuman(autoTitleIssue.Path), atIssue.Title)
	assert.Equal(t, autoTitleIssue.Status, atIssue.Status)
	assert.Equal(t, autoTitleIssue.Tags, atIssue.Tags)
	assert.Equal(t, autoTitleIssue.Blockedby, atIssue.Blockedby)
	assert.Equal(t, autoTitleIssue.Path, atIssue.Path)
}
func Test_Issue_NewFromPath_err_bad_path(t *testing.T) {
	testIssue := Issue{}
	issue, err := Issue.NewFromPath(testIssue, "doesntexist")

	assert.Error(t, err)
	assert.Equal(t, testIssue, issue)
}

func Test_Issue_NewFromPath_success(t *testing.T) {
	testIssue := Issue{
		Title:       "test 1",
		Description: Field{Data: "test description", Path: "/description"},
		Status:      Field{Data: "open:test", 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"},
			},
		},
	}

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

	assert.Equal(t, testIssue.Title, issue.Title)
	assert.Equal(t, testIssue.Description, issue.Description)
	assert.Equal(t, testIssue.Status, issue.Status)
	assert.Equal(t, testIssue.Tags, issue.Tags)
	assert.Equal(t, testIssue.Blockedby, issue.Blockedby)
	assert.Equal(t, testIssue.Path, issue.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)
}