refactor + add tests

Author: binarymason

README.md

@@ -1,4 +1,4 @@
-# go-remote
+# bashRPC
 Simple HTTP server that executes configured commands remotely.
 
 

command.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"os/exec"
+
+	"github.com/pkg/errors"
+)
+
+func runCommand(command string) (out []byte, err error) {
+	out, err = exec.Command("bash", "-c", command).Output()
+
+	if err != nil {
+		return out, errors.Wrap(err, string(out))
+	}
+
+	return
+}

command_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"testing"
+
+	. "github.com/binarymason/bashRPC/internal/testhelpers"
+	"github.com/pkg/errors"
+)
+
+func TestMultilineCommand(t *testing.T) {
+	command := `
+echo foo
+echo bar
+echo baz
+  `
+
+	out, err := runCommand(command)
+	Assert(err, nil, t)
+	Assert(string(out), "foo\nbar\nbaz\n", t)
+}
+
+func TestFailingCommand(t *testing.T) {
+	out, err := runCommand("echo 'BOOM!' && exit 1")
+
+	if err == nil {
+		t.Error("expected an error but received none")
+	}
+
+	Assert(string(out), "BOOM!\n", t)
+	expectedErr := errors.Wrap(errors.New("exit status 1"), "BOOM!\n")
+	Assert(err, expectedErr, t)
+}
+
+func TestPipedCommand(t *testing.T) {
+	command := `echo "it works with pipe" | grep pipe | awk '{ print $1 " " $2 }'`
+	out, err := runCommand(command)
+	Assert(err, nil, t)
+	Assert(string(out), "it works\n", t)
+
+}

config.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"errors"
+	"io/ioutil"
+	"strings"
+
+	"gopkg.in/yaml.v2"
+)
+
+type config struct {
+	Port        string   `yaml:"port"`
+	Secret      string   `yaml:"secret"`
+	Whitelisted []string `yaml:"whitelisted_clients"`
+	Routes      []route  `yaml:"routes"`
+}
+
+type route struct {
+	Path string `yaml:"path"`
+	Cmd  string `yaml:"cmd"`
+}
+
+func loadConfig(p string) (config, error) {
+	cfg := config{}
+	data, err := ioutil.ReadFile(p)
+	if err != nil {
+		return cfg, err
+	}
+
+	err = yaml.Unmarshal([]byte(data), &cfg)
+	return cfg, err
+}
+
+func validateConfig(cfg config) error {
+	var issues []string
+
+	if cfg.Port == "" {
+		issues = append(issues, "port is missing")
+	}
+
+	if cfg.Secret == "" {
+		issues = append(issues, "secret is missing")
+	}
+
+	if len(cfg.Whitelisted) == 0 {
+		issues = append(issues, "no whitelisted clients are specified")
+	}
+
+	if len(issues) > 0 {
+		return errors.New("config validation errors: " + strings.Join(issues, ", "))
+	}
+
+	return nil
+}

main_test.go renamed to config_test.go

@@ -1,37 +1,13 @@
 package main
 
 import (
-	"fmt"
 	"testing"
-)
-
-func Given(s string) {
-	fmt.Println("Given", s)
-}
-
-func When(s string) {
-	fmt.Println("  When", s)
-}
-
-func Then(s string) {
-	fmt.Println("    Then", s)
-}
 
-func And(s string) {
-	fmt.Println("    And", s)
-}
-
-func Assert(a, x interface{}, t *testing.T) {
-
-	a = fmt.Sprintf("%v", a)
-	x = fmt.Sprintf("%v", x)
-	if a != x {
-		t.Errorf("Expected %s, but got: %s", x, a)
-	}
-}
+	. "github.com/binarymason/bashRPC/internal/testhelpers"
+)
 
 func TestLoad(t *testing.T) {
-	cfg, _ := loadConfig("./testdata/simple_config.yml")
+	cfg, _ := loadConfig("./test/data/simple_config.yml")
 	expectedRoutes := []route{
 		route{Path: "/foo", Cmd: "echo foo"},
 		route{Path: "/bar", Cmd: "echo bar"},

internal/testhelpers/testhelpers.go

@@ -0,0 +1,31 @@
+package testhelpers
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Given(s string) {
+	fmt.Println("Given", s)
+}
+
+func When(s string) {
+	fmt.Println("  When", s)
+}
+
+func Then(s string) {
+	fmt.Println("    Then", s)
+}
+
+func And(s string) {
+	fmt.Println("    And", s)
+}
+
+func Assert(a, x interface{}, t *testing.T) {
+
+	a = fmt.Sprintf("%v", a)
+	x = fmt.Sprintf("%v", x)
+	if a != x {
+		t.Errorf("Expected %s, but got: %s", x, a)
+	}
+}

main.go

@@ -1,35 +1,12 @@
 package main
 
 import (
-	"errors"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"log"
-	"net/http"
 	"os"
-	"os/exec"
-	"strings"
-
-	"gopkg.in/yaml.v2"
 )
 
-type config struct {
-	Port        string   `yaml:"port"`
-	Secret      string   `yaml:"secret"`
-	Whitelisted []string `yaml:"whitelisted_clients"`
-	Routes      []route  `yaml:"routes"`
-}
-
-type route struct {
-	Path string `yaml:"path"`
-	Cmd  string `yaml:"cmd"`
-}
-
-type router struct {
-	config config
-}
-
 var configPath string
 
 func init() {
@@ -38,9 +15,6 @@ func init() {
 	configPath = *c
 }
 
-// TODO:
-// * check authorized host
-// * check authorized auth
 func main() {
 	if configPath == "" {
 		fmt.Println("config file argument is required")
@@ -56,119 +30,3 @@ func main() {
 
 	rtr.listen()
 }
-
-func newRouter(p string) (router, error) {
-	rtr := router{}
-	cfg, err := loadConfig(p)
-
-	if err != nil {
-		return rtr, err
-	}
-
-	if err := validateConfig(cfg); err != nil {
-		return rtr, err
-	}
-
-	rtr.config = cfg
-
-	return rtr, nil
-}
-
-func loadConfig(p string) (config, error) {
-	cfg := config{}
-	data, err := ioutil.ReadFile(p)
-	if err != nil {
-		return cfg, err
-	}
-
-	err = yaml.Unmarshal([]byte(data), &cfg)
-	return cfg, err
-}
-
-func validateConfig(cfg config) error {
-	var issues []string
-
-	if cfg.Port == "" {
-		issues = append(issues, "port is missing")
-	}
-
-	if cfg.Secret == "" {
-		issues = append(issues, "secret is missing")
-	}
-
-	if len(cfg.Whitelisted) == 0 {
-		issues = append(issues, "no whitelisted clients are specified")
-	}
-
-	if len(issues) > 0 {
-		return errors.New("config validation errors: " + strings.Join(issues, ", "))
-	}
-
-	return nil
-}
-
-func (rtr *router) listen() {
-	http.HandleFunc("/", rtr.handler)
-
-	fmt.Println("listening on port", rtr.config.Port)
-	http.ListenAndServe(":"+rtr.config.Port, nil)
-
-}
-
-func (rtr *router) handler(w http.ResponseWriter, r *http.Request) {
-	if !rtr.authorizedRequest(r) {
-		http.Error(w, "Unauthorized", http.StatusUnauthorized)
-		return
-	}
-
-	path := r.URL.Path
-
-	route, err := rtr.routeForPath(path)
-
-	if err != nil {
-		http.Error(w, "invalid route", http.StatusNotFound)
-		return
-	}
-
-	command, args := parseCommand(route.Cmd)
-
-	out, err := exec.Command(command, args...).Output()
-	if err != nil {
-		http.Error(w, fmt.Sprintf("%v", err), http.StatusInternalServerError)
-		return
-	}
-
-	w.Write(out)
-}
-
-func (rtr *router) authorizedRequest(r *http.Request) bool {
-	ip := strings.Split(r.RemoteAddr, ":")[0] // remove port
-	auth := r.Header.Get("Authorization")
-
-	return validIP(ip, rtr.config.Whitelisted) && (auth == rtr.config.Secret)
-}
-
-func validIP(ip string, whitelisted []string) bool {
-	for _, w := range whitelisted {
-		if ip == w {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (rtr *router) routeForPath(path string) (r route, err error) {
-	for _, route := range rtr.config.Routes {
-		if route.Path == path {
-			return route, nil
-		}
-	}
-
-	return r, errors.New("Route not found: " + path)
-}
-
-func parseCommand(s string) (c string, args []string) {
-	command := strings.Split(s, " ")
-	return command[0], command[1:]
-}