More consistent naming

internal/server/data/state.go

@@ -7,7 +7,7 @@ import (
 )
 
 type safeHandlerMap struct {
-	h map[string]*model.Handler
+	hs map[string]*model.Handler
 	m  sync.RWMutex
 }
 
@@ -15,26 +15,26 @@ var Handlers = New()
 
 func New() safeHandlerMap {
 	return safeHandlerMap{
-		h: make(map[string]*model.Handler),
+		hs: make(map[string]*model.Handler),
 		m:  sync.RWMutex{},
 	}
 }
 
-func (hs *safeHandlerMap) Add(handler *model.Handler) {
+func (shm *safeHandlerMap) Add(h *model.Handler) {
-	hs.m.Lock()
+	shm.m.Lock()
-	hs.h[handler.Id] = handler
+	shm.hs[h.Id] = h
-	hs.m.Unlock()
+	shm.m.Unlock()
 }
 
-func (hs *safeHandlerMap) Remove(id string) {
+func (shm *safeHandlerMap) Remove(id string) {
-	hs.m.Lock()
+	shm.m.Lock()
-	delete(hs.h, id)
+	delete(shm.hs, id)
-	hs.m.Unlock()
+	shm.m.Unlock()
 }
 
-func (hs *safeHandlerMap) Get(id string) (*model.Handler, bool) {
+func (shm *safeHandlerMap) Get(id string) (*model.Handler, bool) {
-	hs.m.RLock()
+	shm.m.RLock()
-	hndl, ok := hs.h[id]
+	h, ok := shm.hs[id]
-	hs.m.RUnlock()
+	shm.m.RUnlock()
-	return hndl, ok
+	return h, ok
 }

internal/server/data/state_test.go

@@ -10,130 +10,130 @@ import (
 )
 
 func TestNewShouldReturnAnEmptyStruct(t *testing.T) {
-	hs := New()
+	shm := New()
 
-	if len(hs.h) > 0 {
+	if len(shm.hs) > 0 {
 		t.Error("Unexpected member in map")
 	}
 }
 
 func TestAddAddsANewHandlerToTheMap(t *testing.T) {
-	hs := New()
+	shm := New()
 
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	if _, ok := hs.h["FOO"]; !ok {
+	if _, ok := shm.hs["FOO"]; !ok {
 		t.Error("Handler not added to the map")
 	}
 }
 
 func TestAddAdquiresMutexBeforeAdding(t *testing.T) {
-	hs := New()
+	shm := New()
 
-	hs.m.Lock()
+	shm.m.Lock()
-	defer hs.m.Unlock()
+	defer shm.m.Unlock()
-	go hs.Add(&model.Handler{Id: "FOO"})
+	go shm.Add(&model.Handler{Id: "FOO"})
 
 	time.Sleep(10 * time.Millisecond)
 
-	if _, ok := hs.h["FOO"]; ok {
+	if _, ok := shm.hs["FOO"]; ok {
 		t.Error("Handler added while mutex was adquired")
 	}
 }
 
 func TestAddAddsHandlerAfterMutexIsReleased(t *testing.T) {
-	hs := New()
+	shm := New()
 
-	hs.m.Lock()
+	shm.m.Lock()
-	go hs.Add(&model.Handler{Id: "FOO"})
+	go shm.Add(&model.Handler{Id: "FOO"})
-	hs.m.Unlock()
+	shm.m.Unlock()
 
 	time.Sleep(10 * time.Millisecond)
 
-	if _, ok := hs.h["FOO"]; !ok {
+	if _, ok := shm.hs["FOO"]; !ok {
 		t.Error("Handler not added after mutex release")
 	}
 }
 
 func TestRemoveRemovesAHandlerFromTheMap(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.Remove("FOO")
+	shm.Remove("FOO")
 
-	if _, ok := hs.h["FOO"]; ok {
+	if _, ok := shm.hs["FOO"]; ok {
 		t.Error("Handler not removed from the map")
 	}
 }
 
 func TestRemoveAdquiresMutexBeforeRemoving(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
+	shm.m.Lock()
-	defer hs.m.Unlock()
+	defer shm.m.Unlock()
 
-	go hs.Remove("FOO")
+	go shm.Remove("FOO")
 
 	time.Sleep(10 * time.Millisecond)
 
-	if _, ok := hs.h["FOO"]; !ok {
+	if _, ok := shm.hs["FOO"]; !ok {
 		t.Error("Handler was remove while mutex was adquired")
 	}
 }
 
 func TestRemoveRemovesHandlerAfterMutexIsReleased(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
+	shm.m.Lock()
-	go hs.Remove("FOO")
+	go shm.Remove("FOO")
-	hs.m.Unlock()
+	shm.m.Unlock()
 
 	time.Sleep(10 * time.Millisecond)
 
-	if _, ok := hs.h["FOO"]; ok {
+	if _, ok := shm.hs["FOO"]; ok {
 		t.Error("Handler was not removed after mutex release")
 	}
 }
 
 func TestGetReturnFalseWhenHandlerDoesNotExist(t *testing.T) {
-	hs := New()
+	shm := New()
 
-	if _, exists := hs.Get("FOO"); exists {
+	if _, exists := shm.Get("FOO"); exists {
 		t.Error("Get should return false when handler does not exist")
 	}
 
 }
 
 func TestGetReturnTrueWhenHandlerExists(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	if _, exists := hs.Get("FOO"); !exists {
+	if _, exists := shm.Get("FOO"); !exists {
 		t.Error("Get should return true when handler do exist")
 	}
 }
 
 func TestGetReturnExistingHandler(t *testing.T) {
-	hs := New()
+	shm := New()
 	expected := &model.Handler{Id: "FOO"}
-	hs.Add(expected)
+	shm.Add(expected)
 
-	if current, _ := hs.Get("FOO"); current != expected {
+	if current, _ := shm.Get("FOO"); current != expected {
 		t.Error("Get should return true when handler do exist")
 	}
 }
 
 func TestGetWaitsForTheWriterToFinish(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
+	shm.m.Lock()
-	defer hs.m.Unlock()
+	defer shm.m.Unlock()
 
 	c := make(chan *model.Handler)
-	go func() { h, _ := hs.Get("FOO"); c <- h }()
+	go func() { h, _ := shm.Get("FOO"); c <- h }()
 
 	time.Sleep(10 * time.Millisecond)
 
@@ -145,14 +145,14 @@ func TestGetWaitsForTheWriterToFinish(t *testing.T) {
 }
 
 func TestGetNonBlockingReadWithOtherReaders(t *testing.T) {
-	hs := New()
+	shm := New()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.RLock()
+	shm.m.RLock()
-	defer hs.m.RUnlock()
+	defer shm.m.RUnlock()
 
 	c := make(chan *model.Handler)
-	go func() { h, _ := hs.Get("FOO"); c <- h }()
+	go func() { h, _ := shm.Get("FOO"); c <- h }()
 
 	time.Sleep(10 * time.Millisecond)