Merge pull request #1 from Roverr/feature/always_active

Author: Roverr

README.md

@@ -21,6 +21,7 @@ After a configurable time, if no `Hit` were made at all, it deactivates.
 * `Limit`      - int           - _Describes how many times we have to hit before a streak becomes hot_
 * `HotWait`    - time.Duration - _Describes the amount of time we are waiting before declaring a cool down_
 * `ActiveWait` - time.Duration - _Describes the amount of time we are waiting to check on a streak being active_
+* `AlwaysActive` - boolean - _Describes if the streak can deactivate or should stay active forever_
 
 ### Chainability
 Most commands are chainable to allow easier handling.

hotstreak.go

@@ -7,21 +7,20 @@ import (
 
 // Hotstreak is the main structure of the library
 type Hotstreak struct {
-	active     bool
-	hot        bool
-	mux        *sync.Mutex
-	counter    int
-	Limit      int
-	HotWait    time.Duration
-	ActiveWait time.Duration
-	notifier   chan uint8
+	active   bool
+	hot      bool
+	mux      *sync.Mutex
+	counter  int
+	config   Config
+	notifier chan uint8
 }
 
 // Config is the structure of the configuration that can be injected to the lib
 type Config struct {
-	Limit      int           // Describes how many times we have to hit before a streak becomes hot
-	HotWait    time.Duration // Describes the amount of time we are waiting before declaring a cool down
-	ActiveWait time.Duration // Describes the amount of time we are waiting to check on a streak being active
+	Limit        int           // Describes how many times we have to hit before a streak becomes hot
+	HotWait      time.Duration // Describes the amount of time we are waiting before declaring a cool down
+	ActiveWait   time.Duration // Describes the amount of time we are waiting to check on a streak being active
+	AlwaysActive bool          // Describes if the streak can deactivate or not
 }
 
 var (
@@ -45,14 +44,22 @@ func New(config Config) *Hotstreak {
 	if activeWait == 0 {
 		activeWait = time.Minute * 5
 	}
-	return &Hotstreak{Limit: limit, HotWait: hotwait, ActiveWait: activeWait, mux: &sync.Mutex{}, notifier: make(chan uint8)}
+	return &Hotstreak{
+		config: Config{
+			Limit:        limit,
+			HotWait:      hotwait,
+			ActiveWait:   activeWait,
+			AlwaysActive: config.AlwaysActive,
+		},
+		mux:      &sync.Mutex{},
+		notifier: make(chan uint8)}
 }
 
 func (hs *Hotstreak) coolDown() {
 	if hs == nil {
 		return
 	}
-	time.Sleep(hs.HotWait)
+	time.Sleep(hs.config.HotWait)
 	hs.mux.Lock()
 	defer hs.mux.Unlock()
 	hs.hot = false
@@ -66,7 +73,10 @@ func (hs *Hotstreak) dieSlowly() {
 	select {
 	case <-hs.notifier:
 		return
-	case <-time.After(hs.ActiveWait):
+	case <-time.After(hs.config.ActiveWait):
+		if hs.config.AlwaysActive {
+			return
+		}
 		hs.mux.Lock()
 		defer hs.mux.Unlock()
 		if hs.hot || hs.counter > 0 {
@@ -89,7 +99,7 @@ func (hs *Hotstreak) Hit() *Hotstreak {
 		return hs
 	}
 	hs.counter++
-	if hs.counter >= hs.Limit {
+	if hs.counter >= hs.config.Limit {
 		hs.hot = true
 		go hs.coolDown()
 	}

hotstreak_test.go

@@ -12,9 +12,9 @@ func TestCreate(t *testing.T) {
 	assert.False(t, hotstreak.IsActive())
 	assert.False(t, hotstreak.IsHot())
 	assert.Equal(t, hotstreak.counter, 0)
-	assert.Equal(t, hotstreak.Limit, 20)
-	assert.Equal(t, hotstreak.ActiveWait, time.Minute*5)
-	assert.Equal(t, hotstreak.HotWait, time.Minute*5)
+	assert.Equal(t, hotstreak.config.Limit, 20)
+	assert.Equal(t, hotstreak.config.ActiveWait, time.Minute*5)
+	assert.Equal(t, hotstreak.config.HotWait, time.Minute*5)
 }
 
 func TestActivation(t *testing.T) {
@@ -24,14 +24,6 @@ func TestActivation(t *testing.T) {
 		assert.True(t, hotstreak.IsActive())
 	})
 
-	t.Run("Should be able to end activation after wait time", func(t *testing.T) {
-		hotstreak := New(Config{ActiveWait: time.Millisecond * 500})
-		hotstreak.Activate()
-		assert.True(t, hotstreak.IsActive())
-		<-time.After(time.Second)
-		assert.False(t, hotstreak.IsActive())
-	})
-
 	t.Run("Should not deactivate if any hit has been made in the activation time", func(t *testing.T) {
 		hotstreak := New(Config{ActiveWait: time.Millisecond * 500})
 		hotstreak.Activate()
@@ -45,6 +37,24 @@ func TestActivation(t *testing.T) {
 	})
 }
 
+func TestDeactivation(t *testing.T) {
+	t.Run("Should be able to end activation after wait time", func(t *testing.T) {
+		hotstreak := New(Config{ActiveWait: time.Millisecond * 500})
+		hotstreak.Activate()
+		assert.True(t, hotstreak.IsActive())
+		<-time.After(time.Second)
+		assert.False(t, hotstreak.IsActive())
+	})
+
+	t.Run("Should not be able to end activation after wait time if active set to always", func(t *testing.T) {
+		hotstreak := New(Config{ActiveWait: time.Millisecond * 500, AlwaysActive: true})
+		hotstreak.Activate()
+		assert.True(t, hotstreak.IsActive())
+		<-time.After(time.Second)
+		assert.True(t, hotstreak.IsActive())
+	})
+}
+
 func TestHitting(t *testing.T) {
 	t.Run("Should be able to reach being hot", func(t *testing.T) {
 		hotstreak := New(Config{Limit: 2})