issues-go/bug_test.go

package buggo

import (
	"strings"
	"testing"

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

func Test_Bug_View(t *testing.T) {
	bug := Bug{
		Title:       "title",
		Description: Field{Data: "description"},
		Status:      Field{Data: "statustest"},
		Tags: VariadicField{
			Fields: []Field{
				{Data: "tag1"}, {Data: "tag2"},
			}},
		Blockedby: VariadicField{
			Fields: []Field{
				{Data: "blocker1"}, {Data: "blocker2"},
			}},
	}

	output := bug.View()

	assert.True(t, strings.Contains(output, "title"), output)
	assert.True(t, strings.Contains(output, "description"), output)
	// Skip this test until a better testing scheme is present
	//italicize := lipgloss.NewStyle().
	//	Italic(true).
	//	Underline(true)
	//render := italicize.Render("statustest")
	//assert.True(t, strings.Contains(output, render), output)
	assert.True(t, strings.Contains(output, "tag1"), output)
	assert.True(t, strings.Contains(output, "tag2"), output)
	assert.True(t, strings.Contains(output, "blocker1"), output)
	assert.True(t, strings.Contains(output, "blocker2"), output)
}

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_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_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)
}