X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/7b9112dbc270ea338fee756f583bb76870f2e391..cd00c7d65d724ea78fe6e59dda333241a7c0775a:/services/keepproxy/keepproxy_test.go

diff --git a/services/keepproxy/keepproxy_test.go b/services/keepproxy/keepproxy_test.go
index 88ac8a6a1d..ccbd7d8790 100644
--- a/services/keepproxy/keepproxy_test.go
+++ b/services/keepproxy/keepproxy_test.go
@@ -1,11 +1,12 @@
 package main
 
 import (
-	"git.curoverse.com/arvados.git/sdk/go/keepclient"
-	"git.curoverse.com/arvados.git/sdk/go/arvadosclient"
 	"crypto/md5"
 	"crypto/tls"
 	"fmt"
+	"git.curoverse.com/arvados.git/sdk/go/arvadosclient"
+	"git.curoverse.com/arvados.git/sdk/go/arvadostest"
+	"git.curoverse.com/arvados.git/sdk/go/keepclient"
 	. "gopkg.in/check.v1"
 	"io"
 	"io/ioutil"
@@ -13,7 +14,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"os/exec"
+	"strings"
 	"testing"
 	"time"
 )
@@ -29,16 +30,13 @@ var _ = Suite(&ServerRequiredSuite{})
 // Tests that require the Keep server running
 type ServerRequiredSuite struct{}
 
-func pythonDir() string {
-	cwd, _ := os.Getwd()
-	return fmt.Sprintf("%s/../../sdk/python/tests", cwd)
-}
-
 // Wait (up to 1 second) for keepproxy to listen on a port. This
 // avoids a race condition where we hit a "connection refused" error
 // because we start testing the proxy too soon.
 func waitForListener() {
-	const (ms = 5)
+	const (
+		ms = 5
+	)
 	for i := 0; listener == nil && i < 1000; i += ms {
 		time.Sleep(ms * time.Millisecond)
 	}
@@ -54,45 +52,17 @@ func closeListener() {
 }
 
 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
-	cwd, _ := os.Getwd()
-	defer os.Chdir(cwd)
-
-	os.Chdir(pythonDir())
-	{
-		cmd := exec.Command("python", "run_test_server.py", "start")
-		stderr, err := cmd.StderrPipe()
-		if err != nil {
-			log.Fatalf("Setting up stderr pipe: %s", err)
-		}
-		go io.Copy(os.Stderr, stderr)
-		if err := cmd.Run(); err != nil {
-			panic(fmt.Sprintf("'python run_test_server.py start' returned error %s", err))
-		}
-	}
-	{
-		cmd := exec.Command("python", "run_test_server.py", "start_keep")
-		stderr, err := cmd.StderrPipe()
-		if err != nil {
-			log.Fatalf("Setting up stderr pipe: %s", err)
-		}
-		go io.Copy(os.Stderr, stderr)
-		if err := cmd.Run(); err != nil {
-			panic(fmt.Sprintf("'python run_test_server.py start_keep' returned error %s", err))
-		}
-	}
+	arvadostest.StartAPI()
+	arvadostest.StartKeep()
+}
 
-	os.Setenv("ARVADOS_API_HOST", "localhost:3000")
-	os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
-	os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
+func (s *ServerRequiredSuite) SetUpTest(c *C) {
+	arvadostest.ResetEnv()
 }
 
 func (s *ServerRequiredSuite) TearDownSuite(c *C) {
-	cwd, _ := os.Getwd()
-	defer os.Chdir(cwd)
-
-	os.Chdir(pythonDir())
-	exec.Command("python", "run_test_server.py", "stop_keep").Run()
-	exec.Command("python", "run_test_server.py", "stop").Run()
+	arvadostest.StopKeep()
+	arvadostest.StopAPI()
 }
 
 func setupProxyService() {
@@ -133,26 +103,37 @@ func setupProxyService() {
 	}
 }
 
-func runProxy(c *C, args []string, token string, port int) keepclient.KeepClient {
-	os.Args = append(args, fmt.Sprintf("-listen=:%v", port))
-	os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
-
-	go main()
-	time.Sleep(100 * time.Millisecond)
-
-	os.Setenv("ARVADOS_KEEP_PROXY", fmt.Sprintf("http://localhost:%v", port))
-	os.Setenv("ARVADOS_API_TOKEN", token)
+func runProxy(c *C, args []string, port int, bogusClientToken bool) keepclient.KeepClient {
+	if bogusClientToken {
+		os.Setenv("ARVADOS_API_TOKEN", "bogus-token")
+	}
 	arv, err := arvadosclient.MakeArvadosClient()
 	c.Assert(err, Equals, nil)
-	kc, err := keepclient.MakeKeepClient(&arv)
-	c.Assert(err, Equals, nil)
+	kc := keepclient.KeepClient{
+		Arvados: &arv,
+		Want_replicas: 2,
+		Using_proxy: true,
+		Client: &http.Client{},
+	}
+	kc.SetServiceRoots(map[string]string{
+		"proxy": fmt.Sprintf("http://localhost:%v", port),
+	})
 	c.Check(kc.Using_proxy, Equals, true)
 	c.Check(len(kc.ServiceRoots()), Equals, 1)
-	for _, root := range(kc.ServiceRoots()) {
+	for _, root := range kc.ServiceRoots() {
 		c.Check(root, Equals, fmt.Sprintf("http://localhost:%v", port))
 	}
-	os.Setenv("ARVADOS_KEEP_PROXY", "")
 	log.Print("keepclient created")
+	if bogusClientToken {
+		arvadostest.ResetEnv()
+	}
+
+	{
+		os.Args = append(args, fmt.Sprintf("-listen=:%v", port))
+		listener = nil
+		go main()
+	}
+
 	return kc
 }
 
@@ -160,7 +141,7 @@ func (s *ServerRequiredSuite) TestPutAskGet(c *C) {
 	log.Print("TestPutAndGet start")
 
 	os.Args = []string{"keepproxy", "-listen=:29950"}
-	os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
+	listener = nil
 	go main()
 	time.Sleep(100 * time.Millisecond)
 
@@ -178,7 +159,6 @@ func (s *ServerRequiredSuite) TestPutAskGet(c *C) {
 		c.Check(root, Equals, "http://localhost:29950")
 	}
 	os.Setenv("ARVADOS_EXTERNAL_CLIENT", "")
-	log.Print("keepclient created")
 
 	waitForListener()
 	defer closeListener()
@@ -218,18 +198,35 @@ func (s *ServerRequiredSuite) TestPutAskGet(c *C) {
 		log.Print("Get")
 	}
 
+	{
+		var rep int
+		var err error
+		hash2, rep, err = kc.PutB([]byte(""))
+		c.Check(hash2, Matches, `^d41d8cd98f00b204e9800998ecf8427e\+0(\+.+)?$`)
+		c.Check(rep, Equals, 2)
+		c.Check(err, Equals, nil)
+		log.Print("PutB zero block")
+	}
+
+	{
+		reader, blocklen, _, err := kc.Get("d41d8cd98f00b204e9800998ecf8427e")
+		c.Assert(err, Equals, nil)
+		all, err := ioutil.ReadAll(reader)
+		c.Check(all, DeepEquals, []byte(""))
+		c.Check(blocklen, Equals, int64(0))
+		log.Print("Get zero block")
+	}
+
 	log.Print("TestPutAndGet done")
 }
 
 func (s *ServerRequiredSuite) TestPutAskGetForbidden(c *C) {
-	log.Print("TestPutAndGet start")
+	log.Print("TestPutAskGetForbidden start")
 
-	kc := runProxy(c, []string{"keepproxy"}, "123abc", 29951)
+	kc := runProxy(c, []string{"keepproxy"}, 29951, true)
 	waitForListener()
 	defer closeListener()
 
-	log.Print("keepclient created")
-
 	hash := fmt.Sprintf("%x", md5.Sum([]byte("bar")))
 
 	{
@@ -260,13 +257,13 @@ func (s *ServerRequiredSuite) TestPutAskGetForbidden(c *C) {
 		log.Print("Get")
 	}
 
-	log.Print("TestPutAndGetForbidden done")
+	log.Print("TestPutAskGetForbidden done")
 }
 
 func (s *ServerRequiredSuite) TestGetDisabled(c *C) {
 	log.Print("TestGetDisabled start")
 
-	kc := runProxy(c, []string{"keepproxy", "-no-get"}, "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h", 29952)
+	kc := runProxy(c, []string{"keepproxy", "-no-get"}, 29952, false)
 	waitForListener()
 	defer closeListener()
 
@@ -306,7 +303,7 @@ func (s *ServerRequiredSuite) TestGetDisabled(c *C) {
 func (s *ServerRequiredSuite) TestPutDisabled(c *C) {
 	log.Print("TestPutDisabled start")
 
-	kc := runProxy(c, []string{"keepproxy", "-no-put"}, "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h", 29953)
+	kc := runProxy(c, []string{"keepproxy", "-no-put"}, 29953, false)
 	waitForListener()
 	defer closeListener()
 
@@ -320,3 +317,56 @@ func (s *ServerRequiredSuite) TestPutDisabled(c *C) {
 
 	log.Print("TestPutDisabled done")
 }
+
+func (s *ServerRequiredSuite) TestCorsHeaders(c *C) {
+	runProxy(c, []string{"keepproxy"}, 29954, false)
+	waitForListener()
+	defer closeListener()
+
+	{
+		client := http.Client{}
+		req, err := http.NewRequest("OPTIONS",
+			fmt.Sprintf("http://localhost:29954/%x+3",
+				md5.Sum([]byte("foo"))),
+			nil)
+		req.Header.Add("Access-Control-Request-Method", "PUT")
+		req.Header.Add("Access-Control-Request-Headers", "Authorization, X-Keep-Desired-Replicas")
+		resp, err := client.Do(req)
+		c.Check(err, Equals, nil)
+		c.Check(resp.StatusCode, Equals, 200)
+		body, err := ioutil.ReadAll(resp.Body)
+		c.Check(string(body), Equals, "")
+		c.Check(resp.Header.Get("Access-Control-Allow-Methods"), Equals, "GET, HEAD, POST, PUT, OPTIONS")
+		c.Check(resp.Header.Get("Access-Control-Allow-Origin"), Equals, "*")
+	}
+
+	{
+		resp, err := http.Get(
+			fmt.Sprintf("http://localhost:29954/%x+3",
+				md5.Sum([]byte("foo"))))
+		c.Check(err, Equals, nil)
+		c.Check(resp.Header.Get("Access-Control-Allow-Headers"), Equals, "Authorization, Content-Length, Content-Type, X-Keep-Desired-Replicas")
+		c.Check(resp.Header.Get("Access-Control-Allow-Origin"), Equals, "*")
+	}
+}
+
+func (s *ServerRequiredSuite) TestPostWithoutHash(c *C) {
+	runProxy(c, []string{"keepproxy"}, 29955, false)
+	waitForListener()
+	defer closeListener()
+
+	{
+		client := http.Client{}
+		req, err := http.NewRequest("POST",
+			"http://localhost:29955/",
+			strings.NewReader("qux"))
+		req.Header.Add("Authorization", "OAuth2 4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
+		req.Header.Add("Content-Type", "application/octet-stream")
+		resp, err := client.Do(req)
+		c.Check(err, Equals, nil)
+		body, err := ioutil.ReadAll(resp.Body)
+		c.Check(err, Equals, nil)
+		c.Check(string(body), Equals,
+			fmt.Sprintf("%x+%d", md5.Sum([]byte("qux")), 3))
+	}
+}