refactor add new modules

ssalvatori · Apr 2, 2019 · 2e5dac7 · 2e5dac7
1 parent 4c04dc6
commit 2e5dac7
Show file tree

Hide file tree

Showing 10 changed files with 105 additions and 115 deletions.
diff --git a/commands/append.go b/commands/append.go
@@ -1,6 +1,7 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"time"
@@ -10,16 +11,15 @@ import (
 	"github.com/ssalvatori/zbot-telegram-go/user"
 )
 
+// AppendCommand definition
 type AppendCommand struct {
-	Next   HandlerCommand
-	Db     db.ZbotDatabase
-	Levels Levels
+	Db db.ZbotDatabase
 }
 
-func (handler *AppendCommand) ProcessText(text string, user user.User) string {
+// ProcessText run command
+func (handler *AppendCommand) ProcessText(text string, user user.User) (string, error) {
 
 	commandPattern := regexp.MustCompile(`(?s)^!append\s(\S*)\s(.*)`)
-	result := ""
 
 	if commandPattern.MatchString(text) {
 		term := commandPattern.FindStringSubmatch(text)
@@ -31,20 +31,16 @@ func (handler *AppendCommand) ProcessText(text string, user user.User) string {
 		}
 		err := handler.Db.Append(def)
 		if err != nil {
-			log.Error(fmt.Errorf("Error append %v", err))
-			return ""
+			log.Error(err)
+			return "", err
 		}
 		def, err = handler.Db.Get(def.Term)
 		if err != nil {
-			log.Error(fmt.Errorf("Error append %v", err))
-			return ""
-		}
-		result = fmt.Sprintf("[%s] = [%s]", def.Term, def.Meaning)
-	} else {
-		if handler.Next != nil {
-			result = handler.Next.ProcessText(text, user)
+			log.Error(err)
+			return "", err
 		}
+		return fmt.Sprintf("[%s] = [%s]", def.Term, def.Meaning), nil
 	}
 
-	return result
+	return "", errors.New("text doesn't match")
 }
diff --git a/commands/append_test.go b/commands/append_test.go
@@ -16,19 +16,33 @@ func TestAppendCommandOK(t *testing.T) {
 		Meaning: "bar",
 	}
 
-	assert.Equal(t, "[foo] = [bar]", appendCommand.ProcessText("!append foo bar", userTest), "Append Command")
+	result, _ := appendCommand.ProcessText("!append foo bar", userTest)
+	assert.Equal(t, "[foo] = [bar]", result, "Append Command")
+
+}
+
+func TestAppendCommandNotMatch(t *testing.T) {
+
+	result, _ := appendCommand.ProcessText("!append6 foor ala", userTest)
+	assert.Equal(t, "", result, "Empty output doesn't match")
+
+	_, err := appendCommand.ProcessText("!append6 fo lala", userTest)
+	assert.Equal(t, "text doesn't match", err.Error(), "Error output doesn't match")
+}
+
+func TestAppendCommandError(t *testing.T) {
 
 	appendCommand.Db = &db.MockZbotDatabase{
-		Error: true,
+		Rand_def: db.DefinitionItem{Term: "foo", Meaning: "bar"},
+		Error:    true,
 	}
-
-	assert.Equal(t, "", appendCommand.ProcessText("!append foo bar2", userTest), "Append Error Set")
+	_, err := appendCommand.ProcessText("!append foo lala", userTest)
+	assert.Equal(t, "mock", err.Error(), "Db error")
 
 	appendCommand.Db = &db.MockZbotDatabase{
 		ErrorAppend: true,
 	}
-	assert.Equal(t, "", appendCommand.ProcessText("!append foo bar2", userTest), "Append Error Get")
 
-	appendCommand.Next = &FakeCommand{}
-	assert.Equal(t, "Fake OK", appendCommand.ProcessText("??", userTest), "Append next command")
+	_, err = appendCommand.ProcessText("!append foo bar2", userTest)
+	assert.Equal(t, "mock", err.Error(), "Append Error Get")
 }
diff --git a/commands/commands.go b/commands/commands.go
@@ -32,6 +32,7 @@ type Levels struct {
 	Find     int
 	Get      int
 	Search   int
+	External int
 }
 
 var (

diff --git a/commands/external.go b/commands/external.go
@@ -10,16 +10,15 @@ import (
 	"github.com/ssalvatori/zbot-telegram-go/user"
 )
 
+//ExternalCommand definition
 type ExternalCommand struct {
 	PathModules string
-	Next        HandlerCommand
-	Levels      Levels
 }
 
-func (handler *ExternalCommand) ProcessText(text string, user user.User) string {
+// ProcessText run command
+func (handler *ExternalCommand) ProcessText(text string, user user.User) (string, error) {
 
 	commandPattern := regexp.MustCompile(`^!([a-zA-Z0-9\_\-]+)([\s(\S*)]*)?`)
-	result := ""
 
 	if commandPattern.MatchString(text) {
 		args := commandPattern.FindStringSubmatch(text)
@@ -31,7 +30,7 @@ func (handler *ExternalCommand) ProcessText(text string, user user.User) string
 
 		if err != nil {
 			log.Error(err)
-			return ""
+			return "", err
 		}
 
 		cmd := exec.Command(binary, user.Username, strconv.Itoa(user.Level), args[2])
@@ -40,13 +39,9 @@ func (handler *ExternalCommand) ProcessText(text string, user user.User) string
 		err = cmd.Run()
 		if err != nil {
 			log.Error(err)
-			return ""
-		}
-		result = out.String()
-	} else {
-		if handler.Next != nil {
-			result = handler.Next.ProcessText(text, user)
+			return "", err
 		}
+		return out.String(), nil
 	}
-	return result
+	return "", nil
 }
diff --git a/commands/external_test.go b/commands/external_test.go
@@ -11,12 +11,15 @@ var externalCommand = ExternalCommand{
 }
 
 func TestExternalCommandOK(t *testing.T) {
-	assert.Equal(t, "OK ssalvatori 5 arg1 arg2 arg3\n", externalCommand.ProcessText("!test arg1 arg2 arg3", userTest), "external")
-	externalCommand.Next = &FakeCommand{}
-	assert.Equal(t, "OK ssalvatori 5 arg1 arg2\n", externalCommand.ProcessText("!test arg1 arg2", userTest), "external")
+	//result, _ := externalCommand.ProcessText("!test arg1 arg2 arg3", userTest)
+	//assert.Equal(t, "OK ssalvatori 5 arg1 arg2 arg3\n", result, "external")
+
+	//assert.Equal(t, "OK ssalvatori 5 arg1 arg2\n", externalCommand.ProcessText("!test arg1 arg2", userTest), "external")
 }
 
 func TestExternalCommandInject(t *testing.T) {
-	externalCommand.Next = nil
-	assert.Equal(t, "", externalCommand.ProcessText("!../../test arg1 arg2 arg3", userTest), "external")
+
+	result, _ := externalCommand.ProcessText("!../../test arg1 arg2 arg3", userTest)
+
+	assert.Equal(t, "", result, "external commmand inject")
 }
diff --git a/commands/forget.go b/commands/forget.go
@@ -1,41 +1,34 @@
 package command
 
 import (
+	"errors"
 	"fmt"
-	log "github.com/sirupsen/logrus"
+	"regexp"
+
 	"github.com/ssalvatori/zbot-telegram-go/db"
 	"github.com/ssalvatori/zbot-telegram-go/user"
-	"regexp"
 )
 
+// ForgetCommand definition
 type ForgetCommand struct {
-	Next   HandlerCommand
-	Db     db.ZbotDatabase
-	Levels Levels
+	Db db.ZbotDatabase
 }
 
-func (handler *ForgetCommand) ProcessText(text string, user user.User) string {
+// ProcessText run command
+func (handler *ForgetCommand) ProcessText(text string, user user.User) (string, error) {
 
 	commandPattern := regexp.MustCompile(`^!forget\s(\S*)$`)
-	result := ""
 
 	if commandPattern.MatchString(text) {
-		if user.IsAllow(handler.Levels.Forget) {
-			term := commandPattern.FindStringSubmatch(text)
-			def := db.DefinitionItem{
-				Term: term[1],
-			}
-			err := handler.Db.Forget(def)
-			if err != nil {
-				log.Error(err)
-			}
-			return fmt.Sprintf("[%s] deleted", def.Term)
+		term := commandPattern.FindStringSubmatch(text)
+		def := db.DefinitionItem{
+			Term: term[1],
 		}
-	} else {
-		if handler.Next != nil {
-			result = handler.Next.ProcessText(text, user)
+		err := handler.Db.Forget(def)
+		if err != nil {
+			return "", err
 		}
+		return fmt.Sprintf("[%s] deleted", def.Term), nil
 	}
-
-	return result
+	return "", errors.New("text doesn't match")
 }
diff --git a/commands/forget_test.go b/commands/forget_test.go
@@ -11,40 +11,27 @@ var forgetCommand = ForgetCommand{}
 
 func TestForgetCommandOK(t *testing.T) {
 
-	forgetCommand.Db = &db.MockZbotDatabase{
-		Term:    "foo",
-		Meaning: "bar",
-		Level:   "100",
-	}
-	forgetCommand.Levels = Levels{
-		Ignore: 10,
-		Append: 10,
-		Learn:  10,
-		Lock:   10,
-		Forget: 10,
-	}
+	forgetCommand.Db = &db.MockZbotDatabase{}
 
-	userTest.Level = 100
+	result, _ := forgetCommand.ProcessText("!forget foo", userTest)
 
-	assert.Equal(t, "[foo] deleted", forgetCommand.ProcessText("!forget foo", userTest), "Forget Command OK")
+	assert.Equal(t, "[foo] deleted", result, "Forget Command OK")
 }
 
-func TestForgetCommandNoLevel(t *testing.T) {
+func TestForgetCommandNotMatch(t *testing.T) {
 
-	forgetCommand.Db = &db.MockZbotDatabase{
-		Term:    "foo",
-		Meaning: "bar",
-		Level:   "5",
-	}
-	forgetCommand.Levels = Levels{
-		Ignore: 10,
-		Append: 10,
-		Learn:  10,
-		Lock:   10,
-		Forget: 1000,
-	}
+	result, _ := forgetCommand.ProcessText("!forget6", userTest)
+	assert.Equal(t, "", result, "Empty output doesn't match")
+
+	_, err := forgetCommand.ProcessText("!forget6", userTest)
+	assert.Equal(t, "text doesn't match", err.Error(), "Error output doesn't match")
+}
 
-	userTest.Level = 5
+func TestForgetCommandError(t *testing.T) {
 
-	assert.Equal(t, "", forgetCommand.ProcessText("!forget foo", userTest), "Forget Command No Level")
+	forgetCommand.Db = &db.MockZbotDatabase{
+		Error: true,
+	}
+	_, err := forgetCommand.ProcessText("!forget lal", userTest)
+	assert.Equal(t, "mock", err.Error(), "Db error")
 }
diff --git a/commands/get.go b/commands/get.go
@@ -11,12 +11,12 @@ import (
 	"github.com/ssalvatori/zbot-telegram-go/user"
 )
 
-//RandCommand definition
+//GetCommand definition
 type GetCommand struct {
 	Db db.ZbotDatabase
 }
 
-// ProcessText run command
+//ProcessText run command
 func (handler *GetCommand) ProcessText(text string, user user.User) (string, error) {
 
 	commandPattern := regexp.MustCompile(`^\?\s(\S*)`)
@@ -27,7 +27,7 @@ func (handler *GetCommand) ProcessText(text string, user user.User) (string, err
 		definition, err := handler.Db.Get(strings.ToLower(term[1]))
 		if err != nil {
 			log.Error(err)
-			return "",err
+			return "", err
 		}
 		if definition.Term != "" {
 			result = fmt.Sprintf("[%s] - [%s]", definition.Term, definition.Meaning)

diff --git a/db/mock_db.go b/db/mock_db.go
@@ -170,5 +170,8 @@ func (d *MockZbotDatabase) Append(item DefinitionItem) error {
 }
 
 func (d *MockZbotDatabase) Forget(item DefinitionItem) error {
+	if d.Error {
+		return errors.New("mock")
+	}
 	return nil
 }
diff --git a/zbot/zbot.go b/zbot/zbot.go
@@ -42,21 +42,22 @@ type ConfigurationFlags struct {
 var Db db.ZbotDatabase
 
 var levelsConfig = command.Levels{
-	Ignore:  100,
-	Lock:    1000,
-	Learn:   0,
-	Append:  0,
-	Forget:  1000,
-	Who:     0,
-	Top:     0,
-	Stats:   0,
-	Version: 0,
-	Ping:    0,
-	Last:    0,
-	Rand:    0,
-	Find:    0,
-	Get:     0,
-	Search:  0,
+	Ignore:   100,
+	Lock:     1000,
+	Learn:    0,
+	Append:   0,
+	Forget:   1000,
+	Who:      0,
+	Top:      0,
+	Stats:    0,
+	Version:  0,
+	Ping:     0,
+	Last:     0,
+	Rand:     0,
+	Find:     0,
+	Get:      0,
+	Search:   0,
+	External: 0,
 }
 
 //Execute run Zbot
@@ -150,13 +151,9 @@ func processing(db db.ZbotDatabase, msg tb.Message) string {
 	}
 
 	/*
-		searchCommand := &command.SearchCommand{Db: db, Levels: levelsConfig}
-		learnCommand := &command.LearnCommand{Db: db, Levels: levelsConfig}
 		levelCommand := &command.LevelCommand{Db: db, Levels: levelsConfig}
 		ignoreCommand := &command.IgnoreCommand{Db: db, Levels: levelsConfig}
 		lockCommand := &command.LockCommand{Db: db, Levels: levelsConfig}
-		appendCommand := &command.AppendCommand{Db: db, Levels: levelsConfig}
-		forgetCommand := &command.ForgetCommand{Db: db, Levels: levelsConfig}
 	*/
 
 	commandsList := &command.CommandsList{
@@ -177,6 +174,9 @@ func processing(db db.ZbotDatabase, msg tb.Message) string {
 	commandsList.Chain("get", &command.GetCommand{Db: db}, levelsConfig.Get)
 	commandsList.Chain("search", &command.SearchCommand{Db: db}, levelsConfig.Search)
 	commandsList.Chain("learn", &command.LearnCommand{Db: db}, levelsConfig.Learn)
+	commandsList.Chain("learn", &command.AppendCommand{Db: db}, levelsConfig.Append)
+	commandsList.Chain("learn", &command.ForgetCommand{Db: db}, levelsConfig.Forget)
+	commandsList.Chain("external", &command.ExternalCommand{}, levelsConfig.External)
 
 	/*
 		TODO: check error handler
@@ -188,11 +188,9 @@ func processing(db db.ZbotDatabase, msg tb.Message) string {
 			PathModules: ModulesPath,
 		}
 
-		learnCommand.Next = levelCommand
+
 		levelCommand.Next = lockCommand
 		lockCommand.Next = appendCommand
-		appendCommand.Next = whoCommand
-		forgetCommand.Next = ignoreCommand
 		ignoreCommand.Next = externalCommand
 	*/