Add the friendlyNames

Inspire by the the PR Kong#459 Use FriendlyNames. Use the ID and the email of a Developer
https://github.com/Kong/deck/pull/459/files

file/builder_test.go

@@ -1855,15 +1855,18 @@ func Test_stateBuilder_documents(t *testing.T) {
 func Test_stateBuilder_developers(t *testing.T) {
 	assert := assert.New(t)
 	rand.Seed(42)
+
 	type fields struct {
 		currentState  *state.KongState
 		targetContent *Content
 	}
+
 	tests := []struct {
 		name   string
 		fields fields
 		want   *utils.KongRawState
-	}{
+	}
+	{
 		{
 			name: "generates ID for a non-existing developer",
 			fields: fields{
@@ -1911,6 +1914,7 @@ func Test_stateBuilder_developers(t *testing.T) {
 			},
 		},
 	}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			b := &stateBuilder{

file/kong_json_schema.json

@@ -465,10 +465,6 @@
       ]
     },
     "FDeveloper": {
-      "required": [
-        "id",
-        "email"
-      ],
       "properties": {
         "created_at": {
           "type": "integer"

file/types.go

@@ -599,10 +599,10 @@ type FDeveloper struct {
 
 // sortKey is used for sorting.
 func (d FDeveloper) sortKey() string {
-	if d.ID != nil {
+	if d.Email != nil {
 		return *d.ID
 	}
-	if d.Email != nil {
+	if d.ID != nil {
 		return *d.Email
 	}
 	return ""

file/writer.go

@@ -622,12 +622,14 @@ func populateDevelopers(kongState *state.KongState, file *Content,
 	if err != nil {
 		return err
 	}
+
 	for _, d := range developers {
 		d := FDeveloper{Developer: d.Developer}
 		utils.ZeroOutID(&d, d.Email, config.WithID)
 		utils.ZeroOutTimestamps(&d)
 		file.Developers = append(file.Developers, d)
 	}
+
 	sort.SliceStable(file.Developers, func(i, j int) bool {
 		return compareOrder(file.Developers[i], file.Developers[j])
 	})

state/developer_test.go

@@ -34,35 +34,37 @@ func TestDeveloperGetUpdate(t *testing.T) {
 	var developer Developer
 	developer.ID = kong.String("first")
 	developer.Email = kong.String("my-name")
+
 	err := collection.Add(developer)
 	assert.Nil(err)
 
-	c, err := collection.Get("")
+	d, err := collection.Get("")
 	assert.NotNil(err)
-	assert.Nil(c)
+	assert.Nil(d)
 
-	c, err = collection.Get("first")
+	d, err = collection.Get("first")
 	assert.Nil(err)
-	assert.NotNil(c)
+	assert.NotNil(d)
+
+	d.ID = nil
+	d.Email = kong.String("my-updated-name")
 
-	c.ID = nil
-	c.Email = kong.String("my-updated-name")
-	err = collection.Update(*c)
+	err = collection.Update(*d)
 	assert.NotNil(err)
 
-	c.ID = kong.String("does-not-exist")
-	assert.NotNil(collection.Update(*c))
+	d.ID = kong.String("does-not-exist")
+	assert.NotNil(collection.Update(*d))
 
-	c.ID = kong.String("first")
-	assert.Nil(collection.Update(*c))
+	d.ID = kong.String("first")
+	assert.Nil(collection.Update(*d))
 
-	c, err = collection.Get("my-name")
+	d, err = collection.Get("my-name")
 	assert.NotNil(err)
-	assert.Nil(c)
+	assert.Nil(d)
 
-	c, err = collection.Get("my-updated-name")
+	d, err = collection.Get("my-updated-name")
 	assert.Nil(err)
-	assert.NotNil(c)
+	assert.NotNil(d)
 }
 
 // Test to ensure that the memory reference of the pointer returned by Get()
@@ -74,29 +76,30 @@ func TestDeveloperGetMemoryReference(t *testing.T) {
 	var developer Developer
 	developer.ID = kong.String("first")
 	developer.Email = kong.String("my-name")
+
 	err := collection.Add(developer)
 	assert.Nil(err)
 
-	c, err := collection.Get("first")
+	d, err := collection.Get("first")
 	assert.Nil(err)
-	assert.NotNil(c)
-	c.Email = kong.String("update-should-not-reflect")
+	assert.NotNil(d)
+	d.Email = kong.String("update-should-not-reflect")
 
-	c, err = collection.Get("first")
+	d, err = collection.Get("first")
 	assert.Nil(err)
-	assert.Equal("my-name", *c.Email)
+	assert.Equal("my-name", *d.Email)
 }
 
 func TestDevelopersInvalidType(t *testing.T) {
 	assert := assert.New(t)
 	collection := developersCollection()
 
-	type c2 Developer
-	var c c2
-	c.Email = kong.String("my-name")
-	c.ID = kong.String("first")
+	type d2 Developer
+	var d d2
+	d.Email = kong.String("my-name")
+	d.ID = kong.String("first")
 	txn := collection.db.Txn(true)
-	assert.Nil(txn.Insert(developerTableName, &c))
+	assert.Nil(txn.Insert(developerTableName, &d))
 	txn.Commit()
 
 	assert.Panics(func() {
@@ -117,18 +120,18 @@ func TestDeveloperDelete(t *testing.T) {
 	err := collection.Add(developer)
 	assert.Nil(err)
 
-	c, err := collection.Get("my-developer")
+	d, err := collection.Get("my-developer")
 	assert.Nil(err)
-	assert.NotNil(c)
-	assert.Equal("first", *c.ID)
+	assert.NotNil(d)
+	assert.Equal("first", *d.ID)
 
 	err = collection.Delete("first")
 	assert.Nil(err)
 
 	err = collection.Delete("")
 	assert.NotNil(err)
 
-	err = collection.Delete(*c.ID)
+	err = collection.Delete(*d.ID)
 	assert.NotNil(err)
 }
 

state/types.go

@@ -532,18 +532,10 @@ type Developer struct {
 	Meta
 }
 
-// Identifier returns the endpoint key email or ID.
-func (d1 *Developer) Identifier() string {
-	if d1.Email != nil {
-		return *d1.Email
-	}
-	return *d1.ID
-}
-
 // Console returns an entity's identity in a human
 // readable string.
 func (d1 *Developer) Console() string {
-	return d1.Identifier()
+	return d1.FriendlyName()
 }
 
 // Equal returns true if d1 and d2 are equal.

state/types_test.go

@@ -344,6 +344,7 @@ func TestDeveloperEqual(t *testing.T) {
 	d2.Email = kong.String("bar")
 	assert.True(d1.Equal(&d2))
 	assert.True(d1.EqualWithOpts(&d2, false, false))
+
 	d1.Tags = getTags(true)
 	d2.Tags = getTags(false)
 	assert.True(d1.EqualWithOpts(&d2, false, false))

types/developer.go

@@ -43,6 +43,7 @@ func (s *developerCRUD) Create(ctx context.Context, arg ...crud.Arg) (crud.Arg,
 func (s *developerCRUD) Delete(ctx context.Context, arg ...crud.Arg) (crud.Arg, error) {
 	event := crud.EventFromArg(arg[0])
 	developer := developerFromStruct(event)
+
 	err := s.client.Developers.Delete(ctx, developer.ID)
 	if err != nil {
 		return nil, err
@@ -104,7 +105,7 @@ func (d *developerDiffer) deleteDeveloper(developer *state.Developer) (*crud.Eve
 	}
 	if err != nil {
 		return nil, fmt.Errorf("looking up developer %q: %w",
-			developer.Identifier(), err)
+			developer.FriendlyName(), err)
 	}
 	return nil, nil
 }
@@ -144,7 +145,7 @@ func (d *developerDiffer) createUpdateDeveloper(developer *state.Developer) (*cr
 	}
 	if err != nil {
 		return nil, fmt.Errorf("error looking up developer %q: %w",
-			developer.Identifier(), err)
+			developer.FriendlyName(), err)
 	}
 
 	// found, check if update needed