add superficial tests

Author: keks

http/handler_test.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"net/http/httptest"
 	"runtime"
 
@@ -200,6 +201,31 @@ var (
 				},
 			},
 
+			"echo": &cmds.Command{
+				Arguments: []cmdkit.Argument{
+					cmdkit.FileArg("file", true, false, "a file"),
+				},
+				Type: "",
+				Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) error {
+					err := re.Emit("i received:")
+					if err != nil {
+						return err
+					}
+
+					f, err := req.Files.NextFile()
+					if err != nil {
+						return err
+					}
+
+					data, err := ioutil.ReadAll(f)
+					if err != nil {
+						return err
+					}
+
+					return re.Emit(string(data))
+				},
+			},
+
 			"version": &cmds.Command{
 				Helptext: cmdkit.HelpText{
 					Tagline:          "Show ipfs version information.",

http/http_test.go

@@ -12,12 +12,15 @@ import (
 	"testing"
 
 	"github.com/ipfs/go-ipfs-cmds"
+	"github.com/ipfs/go-ipfs-files"
 )
 
 func TestHTTP(t *testing.T) {
 	type testcase struct {
 		path    []string
 		v       interface{}
+		vs      []interface{}
+		file    files.File
 		r       string
 		err     error
 		sendErr error
@@ -56,6 +59,22 @@ func TestHTTP(t *testing.T) {
 			path: []string{"reader"},
 			r:    "the reader call returns a reader.",
 		},
+
+		{
+			path: []string{"echo"},
+			file: files.NewSliceFile(
+				"",
+				"",
+				[]files.File{
+					files.NewReaderFile(
+						"stdin",
+						"/dev/stdin",
+						readCloser{
+							Reader: bytes.NewBufferString("This is the body of the request!"),
+							Closer: nopCloser{},
+						}, nil)}),
+			vs: []interface{}{"i received:", "This is the body of the request!"},
+		},
 	}
 
 	mkTest := func(tc testcase) func(*testing.T) {
@@ -67,6 +86,10 @@ func TestHTTP(t *testing.T) {
 				t.Fatal(err)
 			}
 
+			if tc.file != nil {
+				req.Files = tc.file
+			}
+
 			res, err := c.Send(req)
 			if tc.sendErr != nil {
 				if err == nil {
@@ -79,27 +102,55 @@ func TestHTTP(t *testing.T) {
 
 				return
 			} else if err != nil {
-				t.Fatal("unexpected error:", tc.sendErr)
+				t.Fatal("unexpected error:", err)
 			}
 
-			v, err := res.Next()
-			t.Log("v:", v, "err:", err)
-			if tc.err != nil {
-				if err == nil {
-					t.Error("got nil error, expected:", tc.err)
-				} else if err.Error() != tc.err.Error() {
-					t.Errorf("got error %q, expected %q", err, tc.err)
+			if len(tc.vs) > 0 {
+				for _, tc.v = range tc.vs {
+					v, err := res.Next()
+					if err != nil {
+						t.Error("unexpected error:", err)
+					}
+					// TODO find a better way to solve this!
+					if s, ok := v.(*string); ok {
+						v = *s
+					}
+					t.Log("v:", v, "err:", err)
+
+					// if we don't expect a reader
+					if !reflect.DeepEqual(v, tc.v) {
+						t.Errorf("expected value to be %v but got: %+v", tc.v, v)
+					}
 				}
-			} else if err != nil {
-				t.Fatal("unexpected error:", err)
-			}
 
-			// TODO find a better way to solve this!
-			if s, ok := v.(*string); ok {
-				v = *s
-			}
+				_, err = res.Next()
+				if tc.err != nil {
+					if err == nil {
+						t.Fatal("got nil error, expected:", tc.err)
+					} else if err.Error() != tc.err.Error() {
+						t.Fatalf("got error %q, expected %q", err, tc.err)
+					}
+				} else if err != io.EOF {
+					t.Fatal("expected io.EOF error, got:", err)
+				}
+			} else if len(tc.r) == 0 {
+				v, err := res.Next()
+				// TODO find a better way to solve this!
+				if s, ok := v.(*string); ok {
+					v = *s
+				}
+
+				t.Log("v:", v, "err:", err)
+				if tc.err != nil {
+					if err == nil {
+						t.Error("got nil error, expected:", tc.err)
+					} else if err.Error() != tc.err.Error() {
+						t.Errorf("got error %q, expected %q", err, tc.err)
+					}
+				} else if err != nil {
+					t.Fatal("unexpected error:", err)
+				}
 
-			if len(tc.r) == 0 {
 				// if we don't expect a reader
 				if !reflect.DeepEqual(v, tc.v) {
 					t.Errorf("expected value to be %v but got: %+v", tc.v, v)
@@ -116,14 +167,31 @@ func TestHTTP(t *testing.T) {
 					t.Fatal("expected io.EOF error, got:", err)
 				}
 			} else {
+				v, err := res.Next()
+				// TODO find a better way to solve this!
+				if s, ok := v.(*string); ok {
+					v = *s
+				}
+
+				t.Log("v:", v, "err:", err)
+				if tc.err != nil {
+					if err == nil {
+						t.Error("got nil error, expected:", tc.err)
+					} else if err.Error() != tc.err.Error() {
+						t.Errorf("got error %q, expected %q", err, tc.err)
+					}
+				} else if err != nil {
+					t.Fatal("unexpected error:", err)
+				}
+
 				r, ok := v.(io.Reader)
 				if !ok {
 					t.Fatalf("expected a %T but got a %T", r, v)
 				}
 
 				var buf bytes.Buffer
 
-				_, err := io.Copy(&buf, r)
+				_, err = io.Copy(&buf, r)
 				if err != nil {
 					t.Fatal("unexpected copy error:", err)
 				}
@@ -148,3 +216,12 @@ func TestHTTP(t *testing.T) {
 		t.Run(fmt.Sprintf("%d-%s", i, strings.Join(tc.path, "/")), mkTest(tc))
 	}
 }
+
+type nopCloser struct{}
+
+func (nopCloser) Close() error { return nil }
+
+type readCloser struct {
+	io.Reader
+	io.Closer
+}