dex/vendor/golang.org/x/net/webdav/webdav_test.go

162 lines
4.4 KiB
Go
Raw Normal View History

2016-04-09 00:26:29 +05:30
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package webdav
import (
"fmt"
"io"
"net/http"
"net/http/httptest"
"reflect"
"sort"
"strings"
"testing"
)
// TestStripPrefix tests the StripPrefix function. We can't test the
// StripPrefix function with the litmus test, even though all of the litmus
// test paths start with "/litmus/", because one of the first things that the
// litmus test does is "MKCOL /litmus/". That request succeeds without a
// StripPrefix, but fails with a StripPrefix because you cannot MKCOL the root
// directory of a FileSystem.
func TestStripPrefix(t *testing.T) {
const dst, blah = "Destination", "blah blah blah"
do := func(method, urlStr string, body io.Reader, wantStatusCode int, headers ...string) error {
req, err := http.NewRequest(method, urlStr, body)
if err != nil {
return err
}
for len(headers) >= 2 {
req.Header.Add(headers[0], headers[1])
headers = headers[2:]
}
res, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != wantStatusCode {
return fmt.Errorf("got status code %d, want %d", res.StatusCode, wantStatusCode)
}
return nil
}
prefixes := []string{
"/",
"/a/",
"/a/b/",
"/a/b/c/",
}
for _, prefix := range prefixes {
fs := NewMemFS()
h := http.Handler(&Handler{
FileSystem: fs,
LockSystem: NewMemLS(),
})
mux := http.NewServeMux()
if prefix != "/" {
// Note that this is webdav.StripPrefix, not http.StripPrefix.
h = StripPrefix(prefix, h)
}
mux.Handle(prefix, h)
srv := httptest.NewServer(mux)
defer srv.Close()
// The script is:
// MKCOL /a
// MKCOL /a/b
// PUT /a/b/c
// COPY /a/b/c /a/b/d
// MKCOL /a/b/e
// MOVE /a/b/d /a/b/e/f
// which should yield the (possibly stripped) filenames /a/b/c and
// /a/b/e/f, plus their parent directories.
wantA := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusMovedPermanently,
"/a/b/": http.StatusNotFound,
"/a/b/c/": http.StatusNotFound,
}[prefix]
if err := do("MKCOL", srv.URL+"/a", nil, wantA); err != nil {
t.Errorf("prefix=%-9q MKCOL /a: %v", prefix, err)
continue
}
wantB := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusCreated,
"/a/b/": http.StatusMovedPermanently,
"/a/b/c/": http.StatusNotFound,
}[prefix]
if err := do("MKCOL", srv.URL+"/a/b", nil, wantB); err != nil {
t.Errorf("prefix=%-9q MKCOL /a/b: %v", prefix, err)
continue
}
wantC := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusCreated,
"/a/b/": http.StatusCreated,
"/a/b/c/": http.StatusMovedPermanently,
}[prefix]
if err := do("PUT", srv.URL+"/a/b/c", strings.NewReader(blah), wantC); err != nil {
t.Errorf("prefix=%-9q PUT /a/b/c: %v", prefix, err)
continue
}
wantD := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusCreated,
"/a/b/": http.StatusCreated,
"/a/b/c/": http.StatusMovedPermanently,
}[prefix]
if err := do("COPY", srv.URL+"/a/b/c", nil, wantD, dst, srv.URL+"/a/b/d"); err != nil {
t.Errorf("prefix=%-9q COPY /a/b/c /a/b/d: %v", prefix, err)
continue
}
wantE := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusCreated,
"/a/b/": http.StatusCreated,
"/a/b/c/": http.StatusNotFound,
}[prefix]
if err := do("MKCOL", srv.URL+"/a/b/e", nil, wantE); err != nil {
t.Errorf("prefix=%-9q MKCOL /a/b/e: %v", prefix, err)
continue
}
wantF := map[string]int{
"/": http.StatusCreated,
"/a/": http.StatusCreated,
"/a/b/": http.StatusCreated,
"/a/b/c/": http.StatusNotFound,
}[prefix]
if err := do("MOVE", srv.URL+"/a/b/d", nil, wantF, dst, srv.URL+"/a/b/e/f"); err != nil {
t.Errorf("prefix=%-9q MOVE /a/b/d /a/b/e/f: %v", prefix, err)
continue
}
got, err := find(nil, fs, "/")
if err != nil {
t.Errorf("prefix=%-9q find: %v", prefix, err)
continue
}
sort.Strings(got)
want := map[string][]string{
"/": []string{"/", "/a", "/a/b", "/a/b/c", "/a/b/e", "/a/b/e/f"},
"/a/": []string{"/", "/b", "/b/c", "/b/e", "/b/e/f"},
"/a/b/": []string{"/", "/c", "/e", "/e/f"},
"/a/b/c/": []string{"/"},
}[prefix]
if !reflect.DeepEqual(got, want) {
t.Errorf("prefix=%-9q find:\ngot %v\nwant %v", prefix, got, want)
continue
}
}
}