a97ed10d0b
This commit introduces an api.Cid type and replaces the usage of cid.Cid
everywhere.
The main motivation here is to override MarshalJSON so that Cids are
JSON-ified as '"Qm...."' instead of '{ "/": "Qm....." }', as this "ipld"
representation of IDs is horrible to work with, and our APIs are not issuing
IPLD objects to start with.
Unfortunately, there is no way to do this cleanly, and the best way is to just
switch everything to our own type.
900 lines
20 KiB
Go
900 lines
20 KiB
Go
package ipfsproxy
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ipfs/ipfs-cluster/api"
|
|
"github.com/ipfs/ipfs-cluster/test"
|
|
|
|
cmd "github.com/ipfs/go-ipfs-cmds"
|
|
logging "github.com/ipfs/go-log/v2"
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
)
|
|
|
|
func init() {
|
|
_ = logging.Logger
|
|
}
|
|
|
|
func testIPFSProxyWithConfig(t *testing.T, cfg *Config) (*Server, *test.IpfsMock) {
|
|
mock := test.NewIpfsMock(t)
|
|
nodeMAddr, _ := ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d",
|
|
mock.Addr, mock.Port))
|
|
proxyMAddr, _ := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/0")
|
|
|
|
cfg.NodeAddr = nodeMAddr
|
|
cfg.ListenAddr = []ma.Multiaddr{proxyMAddr}
|
|
cfg.ExtractHeadersExtra = []string{
|
|
test.IpfsCustomHeaderName,
|
|
test.IpfsTimeHeaderName,
|
|
}
|
|
|
|
proxy, err := New(cfg)
|
|
if err != nil {
|
|
t.Fatal("creating an IPFSProxy should work: ", err)
|
|
}
|
|
|
|
proxy.server.SetKeepAlivesEnabled(false)
|
|
proxy.SetClient(test.NewMockRPCClient(t))
|
|
return proxy, mock
|
|
}
|
|
|
|
func testIPFSProxy(t *testing.T) (*Server, *test.IpfsMock) {
|
|
cfg := &Config{}
|
|
cfg.Default()
|
|
return testIPFSProxyWithConfig(t, cfg)
|
|
}
|
|
|
|
func TestIPFSProxyVersion(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
res, err := http.Post(fmt.Sprintf("%s/version", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
if res.StatusCode != http.StatusOK {
|
|
t.Error("the request should have succeeded")
|
|
t.Fatal(string(resBytes))
|
|
}
|
|
|
|
var resp struct {
|
|
Version string
|
|
}
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if resp.Version != "m.o.c.k" {
|
|
t.Error("wrong version")
|
|
}
|
|
}
|
|
|
|
func TestIPFSProxyPin(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
type args struct {
|
|
urlPath string
|
|
testCid string
|
|
statusCode int
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want api.Cid
|
|
wantErr bool
|
|
}{
|
|
{
|
|
"pin good cid query arg",
|
|
args{
|
|
"/pin/add?arg=",
|
|
test.Cid1.String(),
|
|
http.StatusOK,
|
|
},
|
|
test.Cid1,
|
|
false,
|
|
},
|
|
{
|
|
"pin good path query arg",
|
|
args{
|
|
"/pin/add?arg=",
|
|
test.PathIPFS2,
|
|
http.StatusOK,
|
|
},
|
|
test.CidResolved,
|
|
false,
|
|
},
|
|
{
|
|
"pin good cid url arg",
|
|
args{
|
|
"/pin/add/",
|
|
test.Cid1.String(),
|
|
http.StatusOK,
|
|
},
|
|
test.Cid1,
|
|
false,
|
|
},
|
|
{
|
|
"pin bad cid query arg",
|
|
args{
|
|
"/pin/add?arg=",
|
|
test.ErrorCid.String(),
|
|
http.StatusInternalServerError,
|
|
},
|
|
api.CidUndef,
|
|
true,
|
|
},
|
|
{
|
|
"pin bad cid url arg",
|
|
args{
|
|
"/pin/add/",
|
|
test.ErrorCid.String(),
|
|
http.StatusInternalServerError,
|
|
},
|
|
api.CidUndef,
|
|
true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
u := fmt.Sprintf(
|
|
"%s%s%s",
|
|
proxyURL(proxy),
|
|
tt.args.urlPath,
|
|
tt.args.testCid,
|
|
)
|
|
res, err := http.Post(u, "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
|
|
if res.StatusCode != tt.args.statusCode {
|
|
t.Errorf("statusCode: got = %v, want %v", res.StatusCode, tt.args.statusCode)
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
|
|
switch tt.wantErr {
|
|
case false:
|
|
var resp ipfsPinOpResp
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(resp.Pins) != 1 {
|
|
t.Fatalf("wrong number of pins: got = %d, want %d", len(resp.Pins), 1)
|
|
}
|
|
|
|
if resp.Pins[0] != tt.want.String() {
|
|
t.Errorf("wrong pin cid: got = %s, want = %s", resp.Pins[0], tt.want)
|
|
}
|
|
case true:
|
|
var respErr cmd.Error
|
|
err = json.Unmarshal(resBytes, &respErr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if respErr.Message != test.ErrBadCid.Error() {
|
|
t.Errorf("wrong response: got = %s, want = %s", respErr.Message, test.ErrBadCid.Error())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIPFSProxyUnpin(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
type args struct {
|
|
urlPath string
|
|
testCid string
|
|
statusCode int
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want api.Cid
|
|
wantErr bool
|
|
}{
|
|
{
|
|
"unpin good cid query arg",
|
|
args{
|
|
"/pin/rm?arg=",
|
|
test.Cid1.String(),
|
|
http.StatusOK,
|
|
},
|
|
test.Cid1,
|
|
false,
|
|
},
|
|
{
|
|
"unpin good path query arg",
|
|
args{
|
|
"/pin/rm?arg=",
|
|
test.PathIPFS2,
|
|
http.StatusOK,
|
|
},
|
|
test.CidResolved,
|
|
false,
|
|
},
|
|
{
|
|
"unpin good cid url arg",
|
|
args{
|
|
"/pin/rm/",
|
|
test.Cid1.String(),
|
|
http.StatusOK,
|
|
},
|
|
test.Cid1,
|
|
false,
|
|
},
|
|
{
|
|
"unpin bad cid query arg",
|
|
args{
|
|
"/pin/rm?arg=",
|
|
test.ErrorCid.String(),
|
|
http.StatusInternalServerError,
|
|
},
|
|
api.CidUndef,
|
|
true,
|
|
},
|
|
{
|
|
"unpin bad cid url arg",
|
|
args{
|
|
"/pin/rm/",
|
|
test.ErrorCid.String(),
|
|
http.StatusInternalServerError,
|
|
},
|
|
api.CidUndef,
|
|
true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
u := fmt.Sprintf("%s%s%s", proxyURL(proxy), tt.args.urlPath, tt.args.testCid)
|
|
res, err := http.Post(u, "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
|
|
if res.StatusCode != tt.args.statusCode {
|
|
t.Errorf("statusCode: got = %v, want %v", res.StatusCode, tt.args.statusCode)
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
|
|
switch tt.wantErr {
|
|
case false:
|
|
var resp ipfsPinOpResp
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(resp.Pins) != 1 {
|
|
t.Fatalf("wrong number of pins: got = %d, want %d", len(resp.Pins), 1)
|
|
}
|
|
|
|
if resp.Pins[0] != tt.want.String() {
|
|
t.Errorf("wrong pin cid: got = %s, want = %s", resp.Pins[0], tt.want)
|
|
}
|
|
case true:
|
|
var respErr cmd.Error
|
|
err = json.Unmarshal(resBytes, &respErr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if respErr.Message != test.ErrBadCid.Error() {
|
|
t.Errorf("wrong response: got = %s, want = %s", respErr.Message, test.ErrBadCid.Error())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIPFSProxyPinUpdate(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
t.Run("pin/update bad args", func(t *testing.T) {
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/update", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("request should complete: ", err)
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusBadRequest {
|
|
t.Error("request should not be successful with a no arguments")
|
|
}
|
|
|
|
res2, err := http.Post(fmt.Sprintf("%s/pin/update?arg=%s", proxyURL(proxy), test.PathIPFS1), "", nil)
|
|
if err != nil {
|
|
t.Fatal("request should complete: ", err)
|
|
}
|
|
|
|
defer res2.Body.Close()
|
|
if res2.StatusCode != http.StatusBadRequest {
|
|
t.Error("request should not be successful with a single argument")
|
|
}
|
|
})
|
|
|
|
t.Run("pin/update", func(t *testing.T) {
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/update?arg=%s&arg=%s", proxyURL(proxy), test.PathIPFS1, test.PathIPFS2), "", nil)
|
|
if err != nil {
|
|
t.Fatal("request should complete: ", err)
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
|
|
var resp ipfsPinOpResp
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(resp.Pins) != 2 ||
|
|
resp.Pins[0] != test.Cid2.String() ||
|
|
resp.Pins[1] != test.CidResolved.String() { // always resolve to the same
|
|
t.Errorf("bad response: %s", string(resBytes))
|
|
}
|
|
})
|
|
|
|
t.Run("pin/update check unpin happens", func(t *testing.T) {
|
|
// passing an errorCid to unpin should return an error
|
|
// when unpinning.
|
|
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/update?arg=%s&arg=%s", proxyURL(proxy), test.ErrorCid, test.PathIPFS2), "", nil)
|
|
if err != nil {
|
|
t.Fatal("request should complete: ", err)
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusInternalServerError {
|
|
t.Fatal("request should error")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
var respErr cmd.Error
|
|
err = json.Unmarshal(resBytes, &respErr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if respErr.Message != test.ErrBadCid.Error() {
|
|
t.Error("expected a bad cid error:", respErr.Message)
|
|
}
|
|
})
|
|
|
|
t.Run("pin/update check pin happens", func(t *testing.T) {
|
|
// passing an errorCid to pin, with unpin=false should return
|
|
// an error when pinning
|
|
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/update?arg=%s&arg=%s&unpin=false", proxyURL(proxy), test.Cid1, test.ErrorCid), "", nil)
|
|
if err != nil {
|
|
t.Fatal("request should complete: ", err)
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusInternalServerError {
|
|
t.Fatal("request should error")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
var respErr cmd.Error
|
|
err = json.Unmarshal(resBytes, &respErr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if respErr.Message != test.ErrBadCid.Error() {
|
|
t.Error("expected a bad cid error:", respErr.Message)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestIPFSProxyPinLs(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
t.Run("pin/ls query arg", func(t *testing.T) {
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/ls?arg=%s", proxyURL(proxy), test.Cid1), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusOK {
|
|
t.Error("the request should have succeeded")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
var resp ipfsPinLsResp
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, ok := resp.Keys[test.Cid1.String()]
|
|
if len(resp.Keys) != 1 || !ok {
|
|
t.Error("wrong response")
|
|
}
|
|
})
|
|
|
|
t.Run("pin/ls url arg", func(t *testing.T) {
|
|
res, err := http.Post(fmt.Sprintf("%s/pin/ls/%s", proxyURL(proxy), test.Cid1), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusOK {
|
|
t.Error("the request should have succeeded")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
var resp ipfsPinLsResp
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, ok := resp.Keys[test.Cid1.String()]
|
|
if len(resp.Keys) != 1 || !ok {
|
|
t.Error("wrong response")
|
|
}
|
|
})
|
|
|
|
t.Run("pin/ls all no arg", func(t *testing.T) {
|
|
res2, err := http.Post(fmt.Sprintf("%s/pin/ls", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res2.Body.Close()
|
|
if res2.StatusCode != http.StatusOK {
|
|
t.Error("the request should have succeeded")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res2.Body)
|
|
var resp ipfsPinLsResp
|
|
err = json.Unmarshal(resBytes, &resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(resp.Keys) != 3 {
|
|
t.Error("wrong response")
|
|
}
|
|
})
|
|
|
|
t.Run("pin/ls bad cid query arg", func(t *testing.T) {
|
|
res3, err := http.Post(fmt.Sprintf("%s/pin/ls?arg=%s", proxyURL(proxy), test.ErrorCid), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res3.Body.Close()
|
|
if res3.StatusCode != http.StatusInternalServerError {
|
|
t.Error("the request should have failed")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestProxyRepoStat(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
res, err := http.Post(fmt.Sprintf("%s/repo/stat", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusOK {
|
|
t.Error("request should have succeeded")
|
|
}
|
|
|
|
resBytes, _ := ioutil.ReadAll(res.Body)
|
|
var stat api.IPFSRepoStat
|
|
err = json.Unmarshal(resBytes, &stat)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// The mockRPC returns 3 peers. Since no host is set,
|
|
// all calls are local.
|
|
if stat.RepoSize != 6000 || stat.StorageMax != 300000 {
|
|
t.Errorf("expected different stats: %+v", stat)
|
|
}
|
|
|
|
}
|
|
|
|
func TestProxyRepoGC(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
type testcase struct {
|
|
name string
|
|
streamErrors bool
|
|
}
|
|
|
|
testcases := []testcase{
|
|
{
|
|
name: "With streaming errors",
|
|
streamErrors: true,
|
|
},
|
|
{
|
|
name: "Without streaming errors",
|
|
streamErrors: false,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testcases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
res1, err := http.Post(fmt.Sprintf("%s/repo/gc?stream-errors=%t", proxyURL(proxy), tc.streamErrors), "", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer res1.Body.Close()
|
|
if res1.StatusCode != http.StatusOK {
|
|
t.Error("request should have succeeded")
|
|
}
|
|
|
|
var repoGC []ipfsRepoGCResp
|
|
dec := json.NewDecoder(res1.Body)
|
|
for {
|
|
resp := ipfsRepoGCResp{}
|
|
|
|
if err := dec.Decode(&resp); err != nil {
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
t.Error(err)
|
|
}
|
|
|
|
repoGC = append(repoGC, resp)
|
|
}
|
|
|
|
if !repoGC[0].Key.Equals(test.Cid1.Cid) {
|
|
t.Errorf("expected a different cid, expected: %s, found: %s", test.Cid1, repoGC[0].Key)
|
|
}
|
|
|
|
xStreamError, ok := res1.Trailer["X-Stream-Error"]
|
|
if !ok {
|
|
t.Error("trailer header X-Stream-Error not set")
|
|
}
|
|
if tc.streamErrors {
|
|
if repoGC[4].Error != test.ErrLinkNotFound.Error() {
|
|
t.Error("expected a different error")
|
|
}
|
|
if len(xStreamError) != 0 {
|
|
t.Error("expected X-Stream-Error header to be empty")
|
|
}
|
|
} else {
|
|
if repoGC[4].Error != "" {
|
|
t.Error("did not expect to stream error")
|
|
}
|
|
|
|
if len(xStreamError) == 0 || xStreamError[0] != (test.ErrLinkNotFound.Error()+";") {
|
|
t.Error("expected X-Stream-Error header with link not found error")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProxyAdd(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
type testcase struct {
|
|
query string
|
|
expectedCid string
|
|
}
|
|
|
|
testcases := []testcase{
|
|
{
|
|
query: "",
|
|
expectedCid: test.ShardingDirBalancedRootCID,
|
|
},
|
|
{
|
|
query: "progress=true",
|
|
expectedCid: test.ShardingDirBalancedRootCID,
|
|
},
|
|
{
|
|
query: "wrap-with-directory=true",
|
|
expectedCid: test.ShardingDirBalancedRootCIDWrapped,
|
|
},
|
|
{
|
|
query: "trickle=true",
|
|
expectedCid: test.ShardingDirTrickleRootCID,
|
|
},
|
|
}
|
|
|
|
reqs := make([]*http.Request, len(testcases))
|
|
|
|
sth := test.NewShardingTestHelper()
|
|
defer sth.Clean(t)
|
|
|
|
for i, tc := range testcases {
|
|
mr, closer := sth.GetTreeMultiReader(t)
|
|
defer closer.Close()
|
|
cType := "multipart/form-data; boundary=" + mr.Boundary()
|
|
url := fmt.Sprintf("%s/add?"+tc.query, proxyURL(proxy))
|
|
req, _ := http.NewRequest("POST", url, mr)
|
|
req.Header.Set("Content-Type", cType)
|
|
reqs[i] = req
|
|
}
|
|
|
|
for i, tc := range testcases {
|
|
t.Run(tc.query, func(t *testing.T) {
|
|
res, err := http.DefaultClient.Do(reqs[i])
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
if res.StatusCode != http.StatusOK {
|
|
t.Fatalf("Bad response status: got = %d, want = %d", res.StatusCode, http.StatusOK)
|
|
}
|
|
|
|
var resp ipfsAddResp
|
|
dec := json.NewDecoder(res.Body)
|
|
for dec.More() {
|
|
err := dec.Decode(&resp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
if resp.Hash != tc.expectedCid {
|
|
t.Logf("%+v", resp.Hash)
|
|
t.Error("expected CID does not match")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestProxyAddError(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
res, err := http.Post(fmt.Sprintf("%s/add?recursive=true", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
res.Body.Close()
|
|
if res.StatusCode != http.StatusInternalServerError {
|
|
t.Errorf("wrong status code: got = %d, want = %d", res.StatusCode, http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func TestProxyError(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
res, err := http.Post(fmt.Sprintf("%s/bad/command", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should have succeeded: ", err)
|
|
}
|
|
defer res.Body.Close()
|
|
if res.StatusCode != 404 {
|
|
t.Error("should have respected the status code")
|
|
}
|
|
}
|
|
|
|
func proxyURL(c *Server) string {
|
|
addr := c.listeners[0].Addr()
|
|
return fmt.Sprintf("http://%s/api/v0", addr.String())
|
|
}
|
|
|
|
func TestIPFSProxy(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
defer mock.Close()
|
|
if err := proxy.Shutdown(ctx); err != nil {
|
|
t.Error("expected a clean shutdown")
|
|
}
|
|
if err := proxy.Shutdown(ctx); err != nil {
|
|
t.Error("expected a second clean shutdown")
|
|
}
|
|
}
|
|
|
|
func TestHeaderExtraction(t *testing.T) {
|
|
ctx := context.Background()
|
|
proxy, mock := testIPFSProxy(t)
|
|
proxy.config.ExtractHeadersTTL = time.Second
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
req, err := http.NewRequest("POST", fmt.Sprintf("%s/pin/ls", proxyURL(proxy)), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
req.Header.Set("Origin", test.IpfsACAOrigin)
|
|
|
|
res, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
res.Body.Close()
|
|
|
|
for k, v := range res.Header {
|
|
t.Logf("%s: %s", k, v)
|
|
}
|
|
|
|
if h := res.Header.Get("Access-Control-Allow-Origin"); h != test.IpfsACAOrigin {
|
|
t.Error("We did not find out the AC-Allow-Origin header: ", h)
|
|
}
|
|
|
|
for _, h := range corsHeaders {
|
|
if v := res.Header.Get(h); v == "" {
|
|
t.Error("We did not set CORS header: ", h)
|
|
}
|
|
}
|
|
|
|
if res.Header.Get(test.IpfsCustomHeaderName) != test.IpfsCustomHeaderValue {
|
|
t.Error("the proxy should have extracted custom headers from ipfs")
|
|
}
|
|
|
|
if !strings.HasPrefix(res.Header.Get("Server"), "ipfs-cluster") {
|
|
t.Error("wrong value for Server header")
|
|
}
|
|
|
|
// Test ExtractHeaderTTL
|
|
t1 := res.Header.Get(test.IpfsTimeHeaderName)
|
|
res, err = http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
t2 := res.Header.Get(test.IpfsTimeHeaderName)
|
|
if t1 != t2 {
|
|
t.Error("should have cached the headers during TTL")
|
|
}
|
|
time.Sleep(1200 * time.Millisecond)
|
|
res, err = http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
res.Body.Close()
|
|
t3 := res.Header.Get(test.IpfsTimeHeaderName)
|
|
if t3 == t2 {
|
|
t.Error("should have refreshed the headers after TTL")
|
|
}
|
|
}
|
|
|
|
func TestAttackHeaderSize(t *testing.T) {
|
|
const testHeaderSize = minMaxHeaderBytes * 4
|
|
ctx := context.Background()
|
|
cfg := &Config{}
|
|
cfg.Default()
|
|
cfg.MaxHeaderBytes = testHeaderSize
|
|
proxy, mock := testIPFSProxyWithConfig(t, cfg)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
type testcase struct {
|
|
headerSize int
|
|
expectedStatus int
|
|
}
|
|
testcases := []testcase{
|
|
{testHeaderSize / 2, http.StatusNotFound},
|
|
{testHeaderSize * 2, http.StatusRequestHeaderFieldsTooLarge},
|
|
}
|
|
|
|
req, err := http.NewRequest("POST", fmt.Sprintf("%s/foo", proxyURL(proxy)), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, tc := range testcases {
|
|
for size := 0; size < tc.headerSize; size += 8 {
|
|
req.Header.Add("Foo", "bar")
|
|
}
|
|
res, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
res.Body.Close()
|
|
if res.StatusCode != tc.expectedStatus {
|
|
t.Errorf("proxy returned unexpected status %d, expected status code was %d",
|
|
res.StatusCode, tc.expectedStatus)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestProxyLogging(t *testing.T) {
|
|
ctx := context.Background()
|
|
cfg := &Config{}
|
|
cfg.Default()
|
|
|
|
logFile, err := filepath.Abs("proxy.log")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg.LogFile = logFile
|
|
|
|
proxy, mock := testIPFSProxyWithConfig(t, cfg)
|
|
defer os.Remove(cfg.LogFile)
|
|
|
|
info, err := os.Stat(cfg.LogFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if info.Size() > 0 {
|
|
t.Errorf("expected empty log file")
|
|
}
|
|
|
|
res, err := http.Post(fmt.Sprintf("%s/version", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
res.Body.Close()
|
|
|
|
info, err = os.Stat(cfg.LogFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
size1 := info.Size()
|
|
if size1 == 0 {
|
|
t.Error("did not expect an empty log file")
|
|
}
|
|
|
|
// Restart proxy and make sure that logs are being appended
|
|
mock.Close()
|
|
proxy.Shutdown(ctx)
|
|
|
|
proxy, mock = testIPFSProxyWithConfig(t, cfg)
|
|
defer mock.Close()
|
|
defer proxy.Shutdown(ctx)
|
|
|
|
res1, err := http.Post(fmt.Sprintf("%s/version", proxyURL(proxy)), "", nil)
|
|
if err != nil {
|
|
t.Fatal("should forward requests to ipfs host: ", err)
|
|
}
|
|
res1.Body.Close()
|
|
|
|
info, err = os.Stat(cfg.LogFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
size2 := info.Size()
|
|
if size2 == 0 {
|
|
t.Error("did not expect an empty log file")
|
|
}
|
|
|
|
if !(size2 > size1) {
|
|
t.Error("logs were not appended")
|
|
}
|
|
|
|
}
|