func TestMarshalEnumType(t *testing.T) {
	t.Parallel()
	resource.Require(t, resource.UnitTest)

	et := workitem.EnumType{
		SimpleType: workitem.SimpleType{Kind: workitem.KindEnum},
		Values:     []interface{}{"open", "done", "closed"},
	}
	fd := workitem.FieldDefinition{
		Type:     et,
		Required: true,
	}

	expectedWIT := workitem.WorkItemType{
		Name: "first type",
		Fields: map[string]workitem.FieldDefinition{
			"aListType": fd},
	}
	bytes, err := json.Marshal(expectedWIT)
	if err != nil {
		t.Error(err)
	}

	var parsedWIT workitem.WorkItemType
	json.Unmarshal(bytes, &parsedWIT)

	if !expectedWIT.Equal(parsedWIT) {
		t.Errorf("Unmarshalled work item type: \n %v \n has not the same type as \"normal\" workitem type: \n %v \n", parsedWIT, expectedWIT)
	}
}
// TestJsonMarshalListType constructs a work item type, writes it to JSON (marshalling),
// and converts it back from JSON into a work item type (unmarshalling)
func TestJsonMarshalListType(t *testing.T) {
	t.Parallel()
	resource.Require(t, resource.UnitTest)

	lt := workitem.ListType{
		SimpleType:    workitem.SimpleType{Kind: workitem.KindList},
		ComponentType: workitem.SimpleType{Kind: workitem.KindInteger},
	}

	field := workitem.FieldDefinition{
		Type:     lt,
		Required: false,
	}

	expectedWIT := workitem.WorkItemType{
		Name: "first type",
		Fields: map[string]workitem.FieldDefinition{
			"aListType": field},
	}

	bytes, err := json.Marshal(expectedWIT)
	if err != nil {
		t.Error(err)
	}

	var parsedWIT workitem.WorkItemType
	json.Unmarshal(bytes, &parsedWIT)

	if !expectedWIT.Equal(parsedWIT) {
		t.Errorf("Unmarshalled work item type: \n %v \n has not the same type as \"normal\" workitem type: \n %v \n", parsedWIT, expectedWIT)
	}
}
func TestWorkItemType_Equal(t *testing.T) {
	t.Parallel()
	resource.Require(t, resource.UnitTest)

	fd := workitem.FieldDefinition{
		Type: workitem.EnumType{
			SimpleType: workitem.SimpleType{Kind: workitem.KindEnum},
			Values:     []interface{}{"open", "done", "closed"},
		},
		Required: true,
	}

	a := workitem.WorkItemType{
		Name: "foo",
		Fields: map[string]workitem.FieldDefinition{
			"aListType": fd,
		},
	}

	// Test types
	b := convert.DummyEqualer{}
	assert.False(t, a.Equal(b))

	// Test lifecycle
	c := a
	c.Lifecycle = gormsupport.Lifecycle{CreatedAt: time.Now().Add(time.Duration(1000))}
	assert.False(t, a.Equal(c))

	// Test version
	d := a
	d.Version += 1
	assert.False(t, a.Equal(d))

	// Test version
	e := a
	e.Name = "bar"
	assert.False(t, a.Equal(e))

	// Test parent path
	f := a
	f.Path = "foobar"
	assert.False(t, a.Equal(f))

	// Test field array length
	g := a
	g.Fields = map[string]workitem.FieldDefinition{}
	assert.False(t, a.Equal(g))

	// Test field key existence
	h := workitem.WorkItemType{
		Name: "foo",
		Fields: map[string]workitem.FieldDefinition{
			"bar": fd,
		},
	}
	assert.False(t, a.Equal(h))

	// Test field difference
	i := workitem.WorkItemType{
		Name: "foo",
		Fields: map[string]workitem.FieldDefinition{
			"aListType": {
				Type: workitem.EnumType{
					SimpleType: workitem.SimpleType{Kind: workitem.KindEnum},
					Values:     []interface{}{"open", "done", "closed"},
				},
				Required: false,
			},
		},
	}
	assert.False(t, a.Equal(i))

}