Merge pull request #24 from vnteamopen/fix-done-channel

Fix done channel

Author: ledongthuc

debouncer.go

@@ -15,7 +15,7 @@ type Debouncer struct {
 
 // New creates a new instance of debouncer. Each instance of debouncer works independent, concurrency with different wait duration.
 func New(duration time.Duration) *Debouncer {
-	return &Debouncer{timeDuration: duration, triggeredFunc: func() {}, done: make(chan struct{})}
+	return &Debouncer{timeDuration: duration, triggeredFunc: func() {}}
 }
 
 // WithTriggered attached a triggered function to debouncer instance and return the same instance of debouncer to use.
@@ -32,7 +32,8 @@ func (d *Debouncer) SendSignal() {
 	d.Cancel()
 	d.timer = time.AfterFunc(d.timeDuration, func() {
 		d.triggeredFunc()
-		d.done <- struct{}{}
+		close(d.done)
+		d.done = make(chan struct{})
 	})
 }
 
@@ -47,20 +48,22 @@ func (d *Debouncer) Cancel() {
 	if d.timer != nil {
 		d.timer.Stop()
 	}
-	d.done = make(chan struct{})
 }
 
 // UpdateTriggeredFunc replaces triggered function.
 func (d *Debouncer) UpdateTriggeredFunc(newTriggeredFunc func()) {
 	d.triggeredFunc = newTriggeredFunc
 }
 
-// UpdateTimeDuratioe replaces the waiting time duration. You need to call a SendSignal() again to trigger a new timer with a new waiting time duration.
+// UpdateTimeDuration replaces the waiting time duration. You need to call a SendSignal() again to trigger a new timer with a new waiting time duration.
 func (d *Debouncer) UpdateTimeDuration(newTimeDuration time.Duration) {
 	d.timeDuration = newTimeDuration
 }
 
 // Done returns a receive-only channel to notify the caller when the triggered func has been executed.
 func (d *Debouncer) Done() <-chan struct{} {
+	if d.done == nil {
+		d.done = make(chan struct{})
+	}
 	return d.done
 }

debouncer_test.go

@@ -216,17 +216,55 @@ func TestDone(t *testing.T) {
 	debouncer := godebouncer.New(200 * time.Millisecond).WithTriggered(incrementCount)
 	expectedCounter := int(2)
 
-	fmt.Println("Action 1")
 	debouncer.SendSignal()
-	time.Sleep(400 * time.Millisecond)
+	<-debouncer.Done()
+
+	debouncer.SendSignal()
+	<-debouncer.Done()
+
+	if *countPtr != expectedCounter {
+		t.Errorf("Expected count %d, was %d", expectedCounter, *countPtr)
+	}
+}
+
+func TestDoneInGoroutine(t *testing.T) {
+	countPtr, incrementCount := createIncrementCount(0)
+	debouncer := godebouncer.New(200 * time.Millisecond).WithTriggered(incrementCount)
+	expectedCounter := int(3)
 
-	fmt.Println("Action 2")
 	debouncer.SendSignal()
+	go func() {
+		<-debouncer.Done() // awaits for the second send signal to complete
+		*countPtr += 2
+	}()
+
+	debouncer.SendSignal() // after 1 milliseconds, unblock done channel in 2 goroutines
 	<-debouncer.Done()
 
-	fmt.Println(len(debouncer.Done()))
+	time.Sleep(200 * time.Millisecond)
 
 	if *countPtr != expectedCounter {
 		t.Errorf("Expected count %d, was %d", expectedCounter, *countPtr)
 	}
 }
+
+func TestDoneHangBeforeSendSignal(t *testing.T) {
+	debouncer := godebouncer.New(200 * time.Millisecond).WithTriggered(func() {})
+	select {
+	case <-debouncer.Done():
+		t.Error("Done() must hang when being called before SendSignal()")
+	case <-time.After(time.Second):
+	}
+}
+
+func TestDoneHangIfBeingCalledTwice(t *testing.T) {
+	debouncer := godebouncer.New(200 * time.Millisecond).WithTriggered(func() {})
+	debouncer.SendSignal()
+	<-debouncer.Done()
+
+	select {
+	case <-debouncer.Done():
+		t.Error("Done() must hang if being called twice")
+	case <-time.After(time.Second):
+	}
+}