Fixed arg parsing and added tests

Author: paul-mannino

process.go

@@ -2,6 +2,7 @@ package fuzzy
 
 import (
 	"errors"
+	"fmt"
 	"sort"
 )
 
@@ -65,7 +66,11 @@ func ExtractWithoutOrder(query string, choices []string, args ...interface{}) (M
 	}
 	scoreCutoff := 0
 
-	opts, _ := parseArgs(args)
+	opts, err := parseArgs(args...)
+	if err != nil {
+		return nil, err
+	}
+
 	if opts.scorerSet {
 		scorer = opts.scorer
 	}
@@ -103,14 +108,16 @@ func parseArgs(args ...interface{}) (*optionalArgs, error) {
 	processorSet, scorerSet, cutoffSet := false, false, false
 
 	for _, arg := range args {
-		switch arg.(type) {
+		switch v := arg.(type) {
+		default:
+			return nil, fmt.Errorf("not expecting optional argument of type %T", v)
 		case func(string) string:
 			if processorSet {
 				return nil, errors.New("expecting only one processing function of the form f(string)->string")
 			}
 			processor = arg.(func(string) string)
 			processorSet = true
-		case func(string) int:
+		case func(string, string) int:
 			if scorerSet {
 				return nil, errors.New("expecting only one scoring function of the form f(string,string)->int")
 			}
@@ -121,7 +128,9 @@ func parseArgs(args ...interface{}) (*optionalArgs, error) {
 				return nil, errors.New("expecting only one integer scoring cutoff")
 			}
 			scoreCutoff = arg.(int)
+			cutoffSet = true
 		}
+
 	}
 	opts := new(optionalArgs)
 	opts.processor = processor
@@ -134,7 +143,7 @@ func parseArgs(args ...interface{}) (*optionalArgs, error) {
 }
 
 func Extract(query string, choices []string, limit int, args ...interface{}) (MatchPairs, error) {
-	pairs, err := ExtractWithoutOrder(query, choices, args)
+	pairs, err := ExtractWithoutOrder(query, choices, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -143,7 +152,7 @@ func Extract(query string, choices []string, limit int, args ...interface{}) (Ma
 }
 
 func ExtractOne(query string, choices []string, args ...interface{}) (*MatchPair, error) {
-	matches, err := ExtractWithoutOrder(query, choices, args)
+	matches, err := ExtractWithoutOrder(query, choices, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -203,7 +212,7 @@ func Dedupe(sliceWithDupes []string, args ...interface{}) ([]string, error) {
 		case 1:
 			s, err := arg.(func(string, string) int)
 			if err {
-				return nil, errors.New("Expected second optional argument to be a function of the form f(string,string)->int")
+				return nil, errors.New("expected second optional argument to be a function of the form f(string,string)->int")
 			}
 			scorer = s
 		}

process_test.go

@@ -11,6 +11,23 @@ var baseballStrings = []string{
 	"braves vs mets",
 }
 
+var moreBaseballStrings = []string{
+	"new york mets vs chicago cubs",
+	"chicago cubs at new york mets",
+	"atlanta braves vs pittsbugh pirates",
+	"new york yankees vs boston red sox",
+}
+
+var someEmptyStrings = []string{
+	"",
+	"new york mets vs chicago cubs",
+	"new york yankees vs boston red sox",
+	"",
+	"",
+}
+
+var someNullStrings = []string{}
+
 func TestExtractOne(t *testing.T) {
 	query1 := "new york mets at atlanta braves"
 	best1, _ := ExtractOne(query1, baseballStrings)
@@ -37,10 +54,63 @@ func TestExtractOne(t *testing.T) {
 	}
 	best6, _ := ExtractOne(query5, baseballStrings, customScorer)
 	assertMatch(t, query5, baseballStrings[0], best6.Match)
+
+	query7 := "los angeles dodgers vs san francisco giants"
+	scoreCutoff := 50
+	best7, _ := ExtractOne(query7, moreBaseballStrings, scoreCutoff)
+	if best7 != nil {
+		t.Error("expecting to find no matches")
+	}
+
+	query8 := "new york mets vs chicago cubs"
+	scoreCutoff = 100
+	best8, _ := ExtractOne(query8, moreBaseballStrings, scoreCutoff)
+	if best8 == nil {
+		t.Error("expecting to find a match")
+	}
+
+	query9 := "new york mets at chicago cubs"
+	best9, _ := ExtractOne(query9, someEmptyStrings)
+	assertMatch(t, query9, someEmptyStrings[1], best9.Match)
+
+	query10 := "a, b"
+	choices := []string{query10}
+	expectedResult := new(MatchPair)
+	expectedResult.Match = query10
+	expectedResult.Score = 100
+	customScorer = func(s1, s2 string) int {
+		return Ratio(s1, s2)
+	}
+	partialScorer := func(s1, s2 string) int {
+		return PartialRatio(s1, s2)
+	}
+
+	res, _ := ExtractOne(query10, choices, customScorer)
+	partialRes, _ := ExtractOne(query10, choices, partialScorer)
+	if *res != *expectedResult {
+		t.Error("simple match failed")
+	}
+	if *partialRes != *expectedResult {
+		t.Error("simple partial match failed")
+	}
+}
+
+func TestDedupe(t *testing.T) {
+	sliceWithDupes := []string{"Frodo Baggins", "Tom Sawyer", "Bilbo Baggin", "Samuel L. Jackson", "F. Baggins", "Frody Baggins", "Bilbo Baggins"}
+	res, _ := Dedupe(sliceWithDupes)
+	if len(res) >= len(sliceWithDupes) {
+		t.Error("expecting Dedupe to remove at least one string from slice")
+	}
+
+	sliceWithoutDupes := []string{"Tom", "Dick", "Harry"}
+	res2, _ := Dedupe(sliceWithoutDupes)
+	if len(res2) != len(sliceWithoutDupes) {
+		t.Error("not expecting Dedupe to remove any strings from slice")
+	}
 }
 
 func assertMatch(t *testing.T, query, expectedMatch, actualMatch string) {
 	if expectedMatch != actualMatch {
-		t.Errorf("Expecting [%v] to find match of [%v]. Actual match: [%v]", query, expectedMatch, actualMatch)
+		t.Errorf("expecting [%v] to find match of [%v], actual match was [%v]", query, expectedMatch, actualMatch)
 	}
 }