More consistent naming

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()
-	defer hs.m.Unlock()
-	go hs.Add(&model.Handler{Id: "FOO"})
+	shm.m.Lock()
+	defer shm.m.Unlock()
+	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()
-	go hs.Add(&model.Handler{Id: "FOO"})
-	hs.m.Unlock()
+	shm.m.Lock()
+	go shm.Add(&model.Handler{Id: "FOO"})
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
-	defer hs.m.Unlock()
+	shm.m.Lock()
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
-	go hs.Remove("FOO")
-	hs.m.Unlock()
+	shm.m.Lock()
+	go shm.Remove("FOO")
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.Lock()
-	defer hs.m.Unlock()
+	shm.m.Lock()
+	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()
-	hs.Add(&model.Handler{Id: "FOO"})
+	shm := New()
+	shm.Add(&model.Handler{Id: "FOO"})
 
-	hs.m.RLock()
-	defer hs.m.RUnlock()
+	shm.m.RLock()
+	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)