fix: a lot of refactoring and unit test

Author: Matrix86

.gitignore

@@ -11,6 +11,13 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
+# Coverage files
+cover.out
+coverage.txt
+
 # Dependency directories (remove the comment below to include it)
 vendor/
+
 .idea/
+
+bin/

Makefile

@@ -0,0 +1,27 @@
+PROJECT_NAME := "cloudwatcher"
+LDFLAGS="-s -w"
+
+all: build-tests
+
+test:
+	@go test .
+
+test-coverage:
+	@go test -short -coverprofile cover.out -covermode=atomic .
+	@cat cover.out >> coverage.txt
+
+coverage:
+	@go test -coverprofile=cover.out . && go tool cover -html=cover.out
+
+lint:
+	@golint -set_exit_status .
+
+build-tests: clean
+	@mkdir -p bin
+	go build -o bin/dropbox -v -ldflags=${LDFLAGS} examples/dropbox/dropbox.go
+	go build -o bin/gdrive -v -ldflags=${LDFLAGS} examples/gdrive/gdrive.go
+	go build -o bin/local -v -ldflags=${LDFLAGS} examples/local/local.go
+	go build -o bin/s3 -v -ldflags=${LDFLAGS} examples/s3/s3.go
+
+clean:
+	@rm -rf bin

booltype.go

@@ -4,20 +4,27 @@ import (
 	"encoding/json"
 )
 
+// Bool is an alias for the standard boolean type with Unmarshal/Marshal functions
 type Bool bool
 
-func (bit *Bool) UnmarshalJSON(b []byte) error {
+// UnmarshalJSON allows to unmarshal from string to bool
+func (b *Bool) UnmarshalJSON(s []byte) error {
 	var txt string
-	err := json.Unmarshal(b, &txt)
+	err := json.Unmarshal(s, &txt)
 	if err != nil {
 		return err
 	}
-	*bit = Bool(txt == "1" || txt == "true")
+	if txt == "1" || txt == "true" {
+		*b = Bool(true)
+	} else {
+		*b = Bool(false)
+	}
 	return nil
 }
 
-func (bit *Bool) MarshalJSON() ([]byte, error) {
-	if *bit {
+// MarshalJSON allows the conversion from bool to string
+func (b Bool) MarshalJSON() ([]byte, error) {
+	if b {
 		return []byte("true"), nil
 	}
 	return []byte("false"), nil

booltype_test.go

@@ -0,0 +1,71 @@
+package cloudwatcher
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestBool_MarshalJSON(t *testing.T) {
+	type X struct {
+		B Bool
+	}
+
+	x := X{}
+	err := json.Unmarshal([]byte("{\"B\":\"true\"}"), &x)
+	if err != nil {
+		t.Errorf("error during the unmarshalling : %s", err)
+	}
+
+	if x.B == false {
+		t.Errorf("it should be true")
+	}
+
+	err = json.Unmarshal([]byte("{\"B\":\"1\"}"), &x)
+	if err != nil {
+		t.Errorf("error during the unmarshalling : %s", err)
+	}
+
+	if x.B == false {
+		t.Errorf("it should be true")
+	}
+
+	err = json.Unmarshal([]byte("{\"B\":\"false\"}"), &x)
+	if err != nil {
+		t.Errorf("error during the unmarshalling : %s", err)
+	}
+
+	if x.B == true {
+		t.Errorf("it should be false")
+	}
+
+	err = json.Unmarshal([]byte("{\"B\":false}"), &x)
+	if err == nil {
+		t.Errorf("it should return an error")
+	}
+}
+
+func TestBool_UnmarshalJSON(t *testing.T) {
+	type X struct {
+		B Bool
+	}
+
+	x := X{true}
+	j, err := json.Marshal(x)
+	if err != nil {
+		t.Errorf("error during the marshalling : %s", err)
+	}
+
+	if string(j) != "{\"B\":true}" {
+		t.Errorf("marshalling didn't work correctly")
+	}
+
+	x.B = false
+	j, err = json.Marshal(x)
+	if err != nil {
+		t.Errorf("error during the marshalling : %s", err)
+	}
+
+	if string(j) != "{\"B\":false}" {
+		t.Errorf("marshalling didn't work correctly")
+	}
+}

cloudwatcher.go

@@ -6,16 +6,19 @@ import (
 )
 
 type storageFunc func(dir string, interval time.Duration) (Watcher, error)
+
 var supportedServices map[string]storageFunc
 
+// WatcherBase is the struct included in all the specialized watchers
 type WatcherBase struct {
 	Events chan Event
 	Errors chan error
 
-	watchDir string
+	watchDir    string
 	pollingTime time.Duration
 }
 
+// Watcher has to be implemented by all the watchers
 type Watcher interface {
 	Start() error
 	SetConfig(c map[string]string) error
@@ -24,22 +27,26 @@ type Watcher interface {
 	GetErrors() chan error
 }
 
-func New(service string, dir string, interval time.Duration) (Watcher, error) {
-	if f, ok := supportedServices[service]; !ok {
-		return nil, fmt.Errorf("service %s is not yet supported", service)
-	} else {
-		return f(dir, interval)
+// New creates a new instance of a watcher
+func New(serviceName string, dir string, interval time.Duration) (Watcher, error) {
+	f, ok := supportedServices[serviceName]
+	if !ok {
+		return nil, fmt.Errorf("service %s is not yet supported", serviceName)
 	}
+	return f(dir, interval)
+
 }
 
+// GetEvents returns a chan of Event
 func (w *WatcherBase) GetEvents() chan Event {
 	return w.Events
 }
 
+// GetErrors returns a chan of error
 func (w *WatcherBase) GetErrors() chan error {
 	return w.Errors
 }
 
 func init() {
 	supportedServices = make(map[string]storageFunc)
-}
+}

dropbox.go

@@ -3,6 +3,7 @@ package cloudwatcher
 import (
 	"encoding/json"
 	"fmt"
+	"path"
 	"sync/atomic"
 	"time"
 
@@ -11,28 +12,31 @@ import (
 	"golang.org/x/oauth2"
 )
 
+// DropboxWatcher is the specialized watcher for Dropbox service
 type DropboxWatcher struct {
 	WatcherBase
 
 	syncing uint32
 
 	ticker *time.Ticker
 	stop   chan bool
-	config *DropboxConfiguration
+	config *dropboxConfiguration
 	cache  map[string]*DropboxObject
+	client files.Client
 }
 
+// DropboxObject is the object that contains the info of the file
 type DropboxObject struct {
 	Key          string
 	Size         int64
 	LastModified time.Time
 	Hash         string
 }
 
-type DropboxConfiguration struct {
+type dropboxConfiguration struct {
 	Debug        Bool   `json:"debug"`
 	JToken       string `json:"token"`
-	ClientId     string `json:"client_id"`
+	ClientID     string `json:"client_id"`
 	ClientSecret string `json:"client_secret"`
 
 	token *oauth2.Token
@@ -42,6 +46,7 @@ func newDropboxWatcher(dir string, interval time.Duration) (Watcher, error) {
 	w := &DropboxWatcher{
 		cache:  make(map[string]*DropboxObject),
 		config: nil,
+		client: nil,
 		stop:   make(chan bool, 1),
 		WatcherBase: WatcherBase{
 			Events:      make(chan Event, 100),
@@ -54,13 +59,14 @@ func newDropboxWatcher(dir string, interval time.Duration) (Watcher, error) {
 	return w, nil
 }
 
+// SetConfig is used to configure the DropboxWatcher
 func (w *DropboxWatcher) SetConfig(m map[string]string) error {
 	j, err := json.Marshal(m)
 	if err != nil {
 		return err
 	}
 
-	config := DropboxConfiguration{}
+	config := dropboxConfiguration{}
 	if err := json.Unmarshal(j, &config); err != nil {
 		return err
 	}
@@ -78,6 +84,7 @@ func (w *DropboxWatcher) SetConfig(m map[string]string) error {
 	return nil
 }
 
+// Start launches the polling process
 func (w *DropboxWatcher) Start() error {
 	if w.config == nil {
 		return fmt.Errorf("configuration for Dropbox needed")
@@ -102,8 +109,24 @@ func (w *DropboxWatcher) Start() error {
 	return nil
 }
 
+// Close stop the polling process
 func (w *DropboxWatcher) Close() {
-	w.stop <- true
+	if w.stop != nil {
+		w.stop <- true
+	}
+}
+
+func (w *DropboxWatcher) initDropboxClient() {
+	logLevel := dropbox.LogOff
+	if w.config.Debug {
+		logLevel = dropbox.LogDebug
+	}
+
+	config := dropbox.Config{
+		Token:    w.config.token.AccessToken,
+		LogLevel: logLevel,
+	}
+	w.client = files.New(config)
 }
 
 func (w *DropboxWatcher) sync() {
@@ -113,8 +136,11 @@ func (w *DropboxWatcher) sync() {
 	}
 	defer atomic.StoreUint32(&w.syncing, 0)
 
-	fileList := make(map[string]*DropboxObject, 0)
+	if w.client == nil {
+		w.initDropboxClient()
+	}
 
+	fileList := make(map[string]*DropboxObject, 0)
 	err := w.enumerateFiles(w.watchDir, func(obj *DropboxObject) bool {
 		// Store the files to check the deleted one
 		fileList[obj.Key] = obj
@@ -123,7 +149,7 @@ func (w *DropboxWatcher) sync() {
 		// Object has been cached previously by Key
 		if cached != nil {
 			// Check if the LastModified has been changed
-			if !cached.LastModified.Equal(obj.LastModified) || cached.Hash != obj.Hash {
+			if !cached.LastModified.Equal(obj.LastModified) || cached.Hash != obj.Hash || cached.Size != obj.Size {
 				event := Event{
 					Key:    obj.Key,
 					Type:   FileChanged,
@@ -162,29 +188,19 @@ func (w *DropboxWatcher) sync() {
 }
 
 func (w *DropboxWatcher) enumerateFiles(prefix string, callback func(object *DropboxObject) bool) error {
-	logLevel := dropbox.LogOff
-	if w.config.Debug {
-		logLevel = dropbox.LogDebug
-	}
-
-	config := dropbox.Config{
-		Token:    w.config.token.AccessToken,
-		LogLevel: logLevel,
-	}
-	dbx := files.New(config)
 	arg := files.NewListFolderArg(prefix)
 	arg.Recursive = true
 
 	var entries []files.IsMetadata
-	res, err := dbx.ListFolder(arg)
+	res, err := w.client.ListFolder(arg)
 	if err != nil {
 		listRevisionError, ok := err.(files.ListRevisionsAPIError)
 		if ok {
 			// Don't treat a "not_folder" error as fatal; recover by sending a
 			// get_metadata request for the same path and using that response instead.
 			if listRevisionError.EndpointError.Path.Tag == files.LookupErrorNotFolder {
 				var metaRes files.IsMetadata
-				metaRes, err = w.getFileMetadata(dbx, prefix)
+				metaRes, err = w.getFileMetadata(w.client, prefix)
 				entries = []files.IsMetadata{metaRes}
 			} else {
 				// Return if there's an error other than "not_folder" or if the follow-up
@@ -200,7 +216,7 @@ func (w *DropboxWatcher) enumerateFiles(prefix string, callback func(object *Dro
 		for res.HasMore {
 			arg := files.NewListFolderContinueArg(res.Cursor)
 
-			res, err = dbx.ListFolderContinue(arg)
+			res, err = w.client.ListFolderContinue(arg)
 			if err != nil {
 				return err
 			}
@@ -214,10 +230,14 @@ func (w *DropboxWatcher) enumerateFiles(prefix string, callback func(object *Dro
 		switch f := entry.(type) {
 		case *files.FileMetadata:
 			o.Key = f.PathDisplay
+			if f.PathDisplay == "" {
+				o.Key = path.Join(f.PathLower, f.Name)
+			}
 			o.Size = int64(f.Size)
 			o.LastModified = f.ServerModified
 			o.Hash = f.ContentHash
 			callback(o)
+		default:
 		}
 	}