From edb3f6fa1cced4a8db3e4ab0b952fb9bd2bfc18c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Roberto=20Abdelkader=20Mart=C3=ADnez=20P=C3=A9rez?= Date: Sat, 5 Oct 2019 11:44:37 +0200 Subject: [PATCH] More consistent naming --- internal/server/data/state.go | 34 +++++------ internal/server/data/state_test.go | 98 +++++++++++++++--------------- 2 files changed, 66 insertions(+), 66 deletions(-) diff --git a/internal/server/data/state.go b/internal/server/data/state.go index 45471ef..2d44d3a 100644 --- a/internal/server/data/state.go +++ b/internal/server/data/state.go @@ -7,34 +7,34 @@ import ( ) type safeHandlerMap struct { - h map[string]*model.Handler - m sync.RWMutex + hs map[string]*model.Handler + m sync.RWMutex } var Handlers = New() func New() safeHandlerMap { return safeHandlerMap{ - h: make(map[string]*model.Handler), - m: sync.RWMutex{}, + hs: make(map[string]*model.Handler), + m: sync.RWMutex{}, } } -func (hs *safeHandlerMap) Add(handler *model.Handler) { - hs.m.Lock() - hs.h[handler.Id] = handler - hs.m.Unlock() +func (shm *safeHandlerMap) Add(h *model.Handler) { + shm.m.Lock() + shm.hs[h.Id] = h + shm.m.Unlock() } -func (hs *safeHandlerMap) Remove(id string) { - hs.m.Lock() - delete(hs.h, id) - hs.m.Unlock() +func (shm *safeHandlerMap) Remove(id string) { + shm.m.Lock() + delete(shm.hs, id) + shm.m.Unlock() } -func (hs *safeHandlerMap) Get(id string) (*model.Handler, bool) { - hs.m.RLock() - hndl, ok := hs.h[id] - hs.m.RUnlock() - return hndl, ok +func (shm *safeHandlerMap) Get(id string) (*model.Handler, bool) { + shm.m.RLock() + h, ok := shm.hs[id] + shm.m.RUnlock() + return h, ok } diff --git a/internal/server/data/state_test.go b/internal/server/data/state_test.go index 23a65af..a954847 100644 --- a/internal/server/data/state_test.go +++ b/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)