Improviment the tests

args/args.go

@@ -35,7 +35,7 @@ func (a Arguments) Tail() Arguments {
 	if len(a.args) <= 1 {
 		return Arguments{args: []string{}}
 	}
-	return Arguments{args: a.args[1:]}
+	return Arguments{bin: a.bin, args: a.args[1:]}
 }
 
 // Parse is a func to transform the arguments in a struct for easier manipulate the arguments

args/args_test.go

@@ -14,6 +14,15 @@ func TestBinary(t *testing.T) {
 	}
 }
 
+func TestBinaryFromTail(t *testing.T) {
+	in := []string{"binary", "a", "b", "c", "d"}
+	expected := "binary"
+	args := Parse(in).Tail()
+	if result := args.Binary(); result != expected {
+		t.Errorf("unexpected result, result: %v, expected: %v", result, expected)
+	}
+}
+
 func TestCorretArgumentsPassed(t *testing.T) {
 	in := []string{"binary", "a", "b", "c", "d"}
 	expected := fmt.Sprintf("%v", []string{"a", "b", "c", "d"})

cmd/koala/main.go

@@ -51,12 +51,12 @@ func main() {
 
 	currentContent := string(payload)
 
-	targets, err := file.FindOutTarget(tag, currentContent)
+	targets, err := file.FindOutTargets(tag, currentContent)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	newestContent, err := file.ReplaceTarget(targets, currentContent)
+	newestContent, err := file.ReplaceTargets(targets, currentContent)
 	if err != nil {
 		log.Fatal(err)
 	}

file/file.go

@@ -1,6 +1,7 @@
 package file
 
 import (
+	"io/ioutil"
 	"os"
 	"path"
 )
@@ -15,26 +16,18 @@ const (
 // Build is the func to create the bundle file
 func Build(name, s string) (int, error) {
 	dir := path.Dir(name)
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		if err = os.MkdirAll(dir, PermDirectory); err != nil {
-			return 0, err
-		}
+	if err := os.MkdirAll(dir, PermDirectory); err != nil {
 		return 0, err
 	}
 
-	f, err := os.Create(name)
-	if err != nil {
+	if err := ioutil.WriteFile(name, []byte(s), PermFile); err != nil {
 		return 0, err
 	}
 
-	n, err := f.WriteString(s)
+	statFile, err := os.Stat(name)
 	if err != nil {
 		return 0, err
 	}
 
-	if err = f.Chmod(PermFile); err != nil {
-		return 0, err
-	}
-
-	return n, f.Close()
+	return int(statFile.Size()), nil
 }

file/file_test.go

@@ -6,34 +6,41 @@ import (
 	"testing"
 )
 
-const base = "./tmp"
-
 func TestBuildFileIfDirNotExists(t *testing.T) {
-	name := path.Join(base, "1", "llama.txt")
+	name := path.Join(Suite.Temp, "1", "llama.txt")
 	txt := "testing..."
-	if _, err := Build(name, txt); err != nil {
+
+	result, err := Build(name, txt)
+	if err != nil {
 		t.Error(err)
 	}
-	defer func(d string) {
-		if err := os.RemoveAll(d); err != nil {
-			t.Fatal(err)
-		}
-	}(base)
+
+	expected := len([]byte(txt))
+	if result != expected {
+		t.Errorf("unexpected result, result: %v bytes, expected: %v bytes", result, expected)
+	}
+
+	defer Suite.RemoveTemp(t)
 }
 
 func TestBuildFileIfDirAlreadyExists(t *testing.T) {
-	dir := path.Join(base, "2")
+	dir := path.Join(Suite.Temp, "2")
 	name := path.Join(dir, "koala.txt")
 	txt := "testing..."
+
 	if err := os.MkdirAll(dir, PermDirectory); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := Build(name, txt); err != nil {
+
+	result, err := Build(name, txt)
+	if err != nil {
 		t.Error(err)
 	}
-	defer func(d string) {
-		if err := os.RemoveAll(d); err != nil {
-			t.Fatal(err)
-		}
-	}(base)
+
+	expected := len([]byte(txt))
+	if result != expected {
+		t.Errorf("unexpected result, result: %v bytes, expected: %v bytes", result, expected)
+	}
+
+	defer Suite.RemoveTemp(t)
 }

file/target.go

@@ -19,8 +19,8 @@ func (t Target) String() string {
 	return fmt.Sprintf("%s %s", t.Tag, t.Library)
 }
 
-// FindOutTarget is a func to find out target line in entry file
-func FindOutTarget(tag, s string) ([]Target, error) {
+// FindOutTargets is a func to find out target line in entry file
+func FindOutTargets(tag, s string) ([]Target, error) {
 	targets := make([]Target, 0)
 	scnr := bufio.NewScanner(bytes.NewBufferString(s))
 	for scnr.Scan() {
@@ -29,19 +29,22 @@ func FindOutTarget(tag, s string) ([]Target, error) {
 			if len(claimLibrary) > 2 {
 				return nil, errors.New("import syntax wrong")
 			}
-			if len(claimLibrary) == 2 {
+			if len(claimLibrary) == 2 && claimLibrary[0] == tag {
 				targets = append(targets, Target{
 					Tag:     claimLibrary[0],
 					Library: claimLibrary[1],
 				})
 			}
 		}
 	}
+	if len(targets) == 0 {
+		return nil, errors.New("any target founded")
+	}
 	return targets, nil
 }
 
-// ReplaceTarget is a func to replace targets by content from libraries
-func ReplaceTarget(targets []Target, s string) (string, error) {
+// ReplaceTargets is a func to replace targets by content from libraries
+func ReplaceTargets(targets []Target, s string) (string, error) {
 	for _, target := range targets {
 		library, err := ioutil.ReadFile(target.Library)
 		if err != nil {

file/target_test.go

@@ -0,0 +1,76 @@
+package file
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestFindOutTargets(t *testing.T) {
+	tag := "test"
+	data := []byte(`
+test 1
+test 2
+ test 3
+	test 4
+t 4
+te 5
+tes 6
+test 7
+tes 8
+te 9
+t 10
+testing 11
+testin 12
+testi 13
+`)
+	result, err := FindOutTargets(tag, string(data))
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	expected := []Target{
+		{Tag: "test", Library: "1"},
+		{Tag: "test", Library: "2"},
+		{Tag: "test", Library: "7"},
+	}
+	if fmt.Sprintf("%v", result) != fmt.Sprintf("%v", expected) {
+		t.Errorf("unexpected result, result: %v, expected: %v", result, expected)
+	}
+}
+
+type tmpLibrary struct {
+	Path  string
+	Value string
+}
+
+func TestReplaceTags(t *testing.T) {
+	lib := tmpLibrary{
+		Path:  fmt.Sprintf("%v/lib/1", Suite.Temp),
+		Value: "hello 1",
+	}
+
+	Suite.CreateTempFile(lib.Path, lib.Value, t)
+	defer Suite.RemoveTemp(t)
+
+	in := []Target{{Tag: "test", Library: lib.Path}}
+	data := `
+test {{.Path}}
+
+hello test
+`
+	result, err := ReplaceTargets(in, Suite.BuildPayloadFile(data, lib, t))
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	expectedData := `
+{{.Value}}
+
+hello test
+`
+	expected := Suite.BuildPayloadFile(expectedData, lib, t)
+	if result != expected {
+		t.Errorf("unexpected result, result: %v, expected: %v", result, expected)
+	}
+}

file/test.go

@@ -0,0 +1,41 @@
+package file
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/alecthomas/template"
+)
+
+// Suite is a instance of Test struct
+var Suite = &Test{Temp: "./tmp"}
+
+// Test is a struct to help make tests
+type Test struct {
+	Temp string
+}
+
+// BuildPayloadFile is a func to help interpolate value in payload struct of file
+func (tst *Test) BuildPayloadFile(data string, str interface{}, t *testing.T) string {
+	bufferData := bytes.NewBuffer(nil)
+	tmpl := template.Must(template.New("data").Parse(data))
+	if err := tmpl.Execute(bufferData, str); err != nil {
+		t.Fatal(err)
+	}
+	return bufferData.String()
+}
+
+// CreateTempFile is a func to create a file inside temp context
+func (tst *Test) CreateTempFile(path, s string, t *testing.T) {
+	if _, err := Build(path, s); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// RemoveTemp is a func to remove temp folder
+func (tst *Test) RemoveTemp(t *testing.T) {
+	if err := os.RemoveAll(tst.Temp); err != nil {
+		t.Fatal(err)
+	}
+}