func TestConvertJSONAPIToWorkItemWithDescriptionContentAndMarkup(t *testing.T) {
appl := new(application.Application)
attributes := map[string]interface{}{
workitem.SystemTitle: "title",
workitem.SystemDescription: rendering.NewMarkupContent("description", rendering.SystemMarkupMarkdown),
}
source := app.WorkItem2{Type: workitem.SystemBug, Attributes: attributes}
target := &app.WorkItem{Fields: map[string]interface{}{}}
err := ConvertJSONAPIToWorkItem(*appl, source, target)
require.Nil(t, err)
require.NotNil(t, target)
require.NotNil(t, target.Fields)
expectedDescription := rendering.NewMarkupContent("description", rendering.SystemMarkupMarkdown)
assert.Equal(t, expectedDescription, target.Fields[workitem.SystemDescription])
}
func (s *workItemRepoBlackBoxTest) TestCreateWorkItemWithDescriptionMarkup() {
defer cleaner.DeleteCreatedEntities(s.DB)()
wi, err := s.repo.Create(
context.Background(), workitem.SystemBug,
map[string]interface{}{
workitem.SystemTitle: "Title",
workitem.SystemDescription: rendering.NewMarkupContent("Description", rendering.SystemMarkupMarkdown),
workitem.SystemState: workitem.SystemStateNew,
}, "xx")
require.Nil(s.T(), err, "Could not create workitem")
wi, err = s.repo.Load(context.Background(), wi.ID)
require.Nil(s.T(), err)
// app.WorkItem does not contain the markup associated with the description (yet)
assert.Equal(s.T(), rendering.NewMarkupContent("Description", rendering.SystemMarkupMarkdown), wi.Fields[workitem.SystemDescription])
}
// Convert returns the given `value` if the `item` is not nil`, otherwise returns `nil`
func (converter MarkupConverter) Convert(value interface{}, item AttributeAccessor) (interface{}, error) {
// return a 'nil' result if the supplied 'value' was nil
if value == nil {
return nil, nil
}
switch value.(type) {
case string:
return rendering.NewMarkupContent(value.(string), converter.markup), nil
default:
return nil, errors.Errorf("Unexpected type of value to convert: %T", value)
}
}
func TestSimpleTypeConversion(t *testing.T) {
t.Parallel()
resource.Require(t, resource.UnitTest)
markupContent1 := make(map[string]interface{})
markupContent1["content"] = "## description"
markupContent1["markup"] = rendering.SystemMarkupDefault
markupContent2 := make(map[string]interface{})
markupContent2["content"] = "## description"
markupContent2["markup"] = rendering.SystemMarkupMarkdown
test_data := []input{
{stString, "hello world", "hello world", false},
{stString, "", "", false},
{stString, 100, nil, true},
{stString, 1.90, nil, true},
{stIteration, "3434", "3434", false},
{stIteration, "", "", false},
{stIteration, 1, nil, true},
{stIteration, 1.9, nil, true},
{stIteration, true, nil, true},
{stArea, "1233-2333", "1233-2333", false},
{stArea, "", "", false},
{stArea, 1, nil, true},
{stArea, 1.9, nil, true},
{stArea, true, nil, true},
{stInt, 100.0, nil, true},
{stInt, 100, 100, false},
{stInt, "100", nil, true},
{stInt, true, nil, true},
{stFloat, 1.1, 1.1, false},
{stFloat, 1, nil, true},
{stFloat, "a", nil, true},
{stDuration, 0, 0, false},
{stDuration, 1.1, nil, true},
{stDuration, "duration", nil, true},
{stURL, "http://www.google.com", "http://www.google.com", false},
{stURL, "", nil, true},
{stURL, "google", nil, true},
{stURL, "http://google.com", "http://google.com", false},
{stList, [4]int{1, 2, 3, 4}, [4]int{1, 2, 3, 4}, false},
{stList, [2]string{"1", "2"}, [2]string{"1", "2"}, false},
{stList, "", nil, true},
// {stList, []int{}, []int{}, false}, need to find out the way for empty array.
// because slices do not have equality operator.
{stMarkup, rendering.NewMarkupContent("## description", rendering.SystemMarkupDefault), markupContent1, false},
{stMarkup, rendering.NewMarkupContent("## description", rendering.SystemMarkupMarkdown), markupContent2, false},
{stMarkup, nil, nil, false},
{stMarkup, 1, nil, true},
}
for _, inp := range test_data {
retVal, err := inp.t.ConvertToModel(inp.value)
matchContent := reflect.DeepEqual(retVal, inp.expectedValue)
matchError := (err != nil) == inp.errorExpected
if matchContent && matchError {
t.Log("test pass for input: ", inp)
} else if !matchContent {
t.Error("Expected ", inp.expectedValue, "but got", retVal)
t.Fail()
} else {
t.Error("Expected error to be ", inp.errorExpected, "but got", (err != nil))
t.Fail()
}
}
}