summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/net/webdav/lock_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/net/webdav/lock_test.go')
-rw-r--r--vendor/golang.org/x/net/webdav/lock_test.go731
1 files changed, 0 insertions, 731 deletions
diff --git a/vendor/golang.org/x/net/webdav/lock_test.go b/vendor/golang.org/x/net/webdav/lock_test.go
deleted file mode 100644
index 5cf14cd..0000000
--- a/vendor/golang.org/x/net/webdav/lock_test.go
+++ /dev/null
@@ -1,731 +0,0 @@
-// Copyright 2014 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"
- "math/rand"
- "path"
- "reflect"
- "sort"
- "strconv"
- "strings"
- "testing"
- "time"
-)
-
-func TestWalkToRoot(t *testing.T) {
- testCases := []struct {
- name string
- want []string
- }{{
- "/a/b/c/d",
- []string{
- "/a/b/c/d",
- "/a/b/c",
- "/a/b",
- "/a",
- "/",
- },
- }, {
- "/a",
- []string{
- "/a",
- "/",
- },
- }, {
- "/",
- []string{
- "/",
- },
- }}
-
- for _, tc := range testCases {
- var got []string
- if !walkToRoot(tc.name, func(name0 string, first bool) bool {
- if first != (len(got) == 0) {
- t.Errorf("name=%q: first=%t but len(got)==%d", tc.name, first, len(got))
- return false
- }
- got = append(got, name0)
- return true
- }) {
- continue
- }
- if !reflect.DeepEqual(got, tc.want) {
- t.Errorf("name=%q:\ngot %q\nwant %q", tc.name, got, tc.want)
- }
- }
-}
-
-var lockTestDurations = []time.Duration{
- infiniteTimeout, // infiniteTimeout means to never expire.
- 0, // A zero duration means to expire immediately.
- 100 * time.Hour, // A very large duration will not expire in these tests.
-}
-
-// lockTestNames are the names of a set of mutually compatible locks. For each
-// name fragment:
-// - _ means no explicit lock.
-// - i means an infinite-depth lock,
-// - z means a zero-depth lock,
-var lockTestNames = []string{
- "/_/_/_/_/z",
- "/_/_/i",
- "/_/z",
- "/_/z/i",
- "/_/z/z",
- "/_/z/_/i",
- "/_/z/_/z",
- "/i",
- "/z",
- "/z/_/i",
- "/z/_/z",
-}
-
-func lockTestZeroDepth(name string) bool {
- switch name[len(name)-1] {
- case 'i':
- return false
- case 'z':
- return true
- }
- panic(fmt.Sprintf("lock name %q did not end with 'i' or 'z'", name))
-}
-
-func TestMemLSCanCreate(t *testing.T) {
- now := time.Unix(0, 0)
- m := NewMemLS().(*memLS)
-
- for _, name := range lockTestNames {
- _, err := m.Create(now, LockDetails{
- Root: name,
- Duration: infiniteTimeout,
- ZeroDepth: lockTestZeroDepth(name),
- })
- if err != nil {
- t.Fatalf("creating lock for %q: %v", name, err)
- }
- }
-
- wantCanCreate := func(name string, zeroDepth bool) bool {
- for _, n := range lockTestNames {
- switch {
- case n == name:
- // An existing lock has the same name as the proposed lock.
- return false
- case strings.HasPrefix(n, name):
- // An existing lock would be a child of the proposed lock,
- // which conflicts if the proposed lock has infinite depth.
- if !zeroDepth {
- return false
- }
- case strings.HasPrefix(name, n):
- // An existing lock would be an ancestor of the proposed lock,
- // which conflicts if the ancestor has infinite depth.
- if n[len(n)-1] == 'i' {
- return false
- }
- }
- }
- return true
- }
-
- var check func(int, string)
- check = func(recursion int, name string) {
- for _, zeroDepth := range []bool{false, true} {
- got := m.canCreate(name, zeroDepth)
- want := wantCanCreate(name, zeroDepth)
- if got != want {
- t.Errorf("canCreate name=%q zeroDepth=%t: got %t, want %t", name, zeroDepth, got, want)
- }
- }
- if recursion == 6 {
- return
- }
- if name != "/" {
- name += "/"
- }
- for _, c := range "_iz" {
- check(recursion+1, name+string(c))
- }
- }
- check(0, "/")
-}
-
-func TestMemLSLookup(t *testing.T) {
- now := time.Unix(0, 0)
- m := NewMemLS().(*memLS)
-
- badToken := m.nextToken()
- t.Logf("badToken=%q", badToken)
-
- for _, name := range lockTestNames {
- token, err := m.Create(now, LockDetails{
- Root: name,
- Duration: infiniteTimeout,
- ZeroDepth: lockTestZeroDepth(name),
- })
- if err != nil {
- t.Fatalf("creating lock for %q: %v", name, err)
- }
- t.Logf("%-15q -> node=%p token=%q", name, m.byName[name], token)
- }
-
- baseNames := append([]string{"/a", "/b/c"}, lockTestNames...)
- for _, baseName := range baseNames {
- for _, suffix := range []string{"", "/0", "/1/2/3"} {
- name := baseName + suffix
-
- goodToken := ""
- base := m.byName[baseName]
- if base != nil && (suffix == "" || !lockTestZeroDepth(baseName)) {
- goodToken = base.token
- }
-
- for _, token := range []string{badToken, goodToken} {
- if token == "" {
- continue
- }
-
- got := m.lookup(name, Condition{Token: token})
- want := base
- if token == badToken {
- want = nil
- }
- if got != want {
- t.Errorf("name=%-20qtoken=%q (bad=%t): got %p, want %p",
- name, token, token == badToken, got, want)
- }
- }
- }
- }
-}
-
-func TestMemLSConfirm(t *testing.T) {
- now := time.Unix(0, 0)
- m := NewMemLS().(*memLS)
- alice, err := m.Create(now, LockDetails{
- Root: "/alice",
- Duration: infiniteTimeout,
- ZeroDepth: false,
- })
- tweedle, err := m.Create(now, LockDetails{
- Root: "/tweedle",
- Duration: infiniteTimeout,
- ZeroDepth: false,
- })
- if err != nil {
- t.Fatalf("Create: %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Create: inconsistent state: %v", err)
- }
-
- // Test a mismatch between name and condition.
- _, err = m.Confirm(now, "/tweedle/dee", "", Condition{Token: alice})
- if err != ErrConfirmationFailed {
- t.Fatalf("Confirm (mismatch): got %v, want ErrConfirmationFailed", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Confirm (mismatch): inconsistent state: %v", err)
- }
-
- // Test two names (that fall under the same lock) in the one Confirm call.
- release, err := m.Confirm(now, "/tweedle/dee", "/tweedle/dum", Condition{Token: tweedle})
- if err != nil {
- t.Fatalf("Confirm (twins): %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Confirm (twins): inconsistent state: %v", err)
- }
- release()
- if err := m.consistent(); err != nil {
- t.Fatalf("release (twins): inconsistent state: %v", err)
- }
-
- // Test the same two names in overlapping Confirm / release calls.
- releaseDee, err := m.Confirm(now, "/tweedle/dee", "", Condition{Token: tweedle})
- if err != nil {
- t.Fatalf("Confirm (sequence #0): %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Confirm (sequence #0): inconsistent state: %v", err)
- }
-
- _, err = m.Confirm(now, "/tweedle/dum", "", Condition{Token: tweedle})
- if err != ErrConfirmationFailed {
- t.Fatalf("Confirm (sequence #1): got %v, want ErrConfirmationFailed", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Confirm (sequence #1): inconsistent state: %v", err)
- }
-
- releaseDee()
- if err := m.consistent(); err != nil {
- t.Fatalf("release (sequence #2): inconsistent state: %v", err)
- }
-
- releaseDum, err := m.Confirm(now, "/tweedle/dum", "", Condition{Token: tweedle})
- if err != nil {
- t.Fatalf("Confirm (sequence #3): %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Confirm (sequence #3): inconsistent state: %v", err)
- }
-
- // Test that you can't unlock a held lock.
- err = m.Unlock(now, tweedle)
- if err != ErrLocked {
- t.Fatalf("Unlock (sequence #4): got %v, want ErrLocked", err)
- }
-
- releaseDum()
- if err := m.consistent(); err != nil {
- t.Fatalf("release (sequence #5): inconsistent state: %v", err)
- }
-
- err = m.Unlock(now, tweedle)
- if err != nil {
- t.Fatalf("Unlock (sequence #6): %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Unlock (sequence #6): inconsistent state: %v", err)
- }
-}
-
-func TestMemLSNonCanonicalRoot(t *testing.T) {
- now := time.Unix(0, 0)
- m := NewMemLS().(*memLS)
- token, err := m.Create(now, LockDetails{
- Root: "/foo/./bar//",
- Duration: 1 * time.Second,
- })
- if err != nil {
- t.Fatalf("Create: %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Create: inconsistent state: %v", err)
- }
- if err := m.Unlock(now, token); err != nil {
- t.Fatalf("Unlock: %v", err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("Unlock: inconsistent state: %v", err)
- }
-}
-
-func TestMemLSExpiry(t *testing.T) {
- m := NewMemLS().(*memLS)
- testCases := []string{
- "setNow 0",
- "create /a.5",
- "want /a.5",
- "create /c.6",
- "want /a.5 /c.6",
- "create /a/b.7",
- "want /a.5 /a/b.7 /c.6",
- "setNow 4",
- "want /a.5 /a/b.7 /c.6",
- "setNow 5",
- "want /a/b.7 /c.6",
- "setNow 6",
- "want /a/b.7",
- "setNow 7",
- "want ",
- "setNow 8",
- "want ",
- "create /a.12",
- "create /b.13",
- "create /c.15",
- "create /a/d.16",
- "want /a.12 /a/d.16 /b.13 /c.15",
- "refresh /a.14",
- "want /a.14 /a/d.16 /b.13 /c.15",
- "setNow 12",
- "want /a.14 /a/d.16 /b.13 /c.15",
- "setNow 13",
- "want /a.14 /a/d.16 /c.15",
- "setNow 14",
- "want /a/d.16 /c.15",
- "refresh /a/d.20",
- "refresh /c.20",
- "want /a/d.20 /c.20",
- "setNow 20",
- "want ",
- }
-
- tokens := map[string]string{}
- zTime := time.Unix(0, 0)
- now := zTime
- for i, tc := range testCases {
- j := strings.IndexByte(tc, ' ')
- if j < 0 {
- t.Fatalf("test case #%d %q: invalid command", i, tc)
- }
- op, arg := tc[:j], tc[j+1:]
- switch op {
- default:
- t.Fatalf("test case #%d %q: invalid operation %q", i, tc, op)
-
- case "create", "refresh":
- parts := strings.Split(arg, ".")
- if len(parts) != 2 {
- t.Fatalf("test case #%d %q: invalid create", i, tc)
- }
- root := parts[0]
- d, err := strconv.Atoi(parts[1])
- if err != nil {
- t.Fatalf("test case #%d %q: invalid duration", i, tc)
- }
- dur := time.Unix(0, 0).Add(time.Duration(d) * time.Second).Sub(now)
-
- switch op {
- case "create":
- token, err := m.Create(now, LockDetails{
- Root: root,
- Duration: dur,
- ZeroDepth: true,
- })
- if err != nil {
- t.Fatalf("test case #%d %q: Create: %v", i, tc, err)
- }
- tokens[root] = token
-
- case "refresh":
- token := tokens[root]
- if token == "" {
- t.Fatalf("test case #%d %q: no token for %q", i, tc, root)
- }
- got, err := m.Refresh(now, token, dur)
- if err != nil {
- t.Fatalf("test case #%d %q: Refresh: %v", i, tc, err)
- }
- want := LockDetails{
- Root: root,
- Duration: dur,
- ZeroDepth: true,
- }
- if got != want {
- t.Fatalf("test case #%d %q:\ngot %v\nwant %v", i, tc, got, want)
- }
- }
-
- case "setNow":
- d, err := strconv.Atoi(arg)
- if err != nil {
- t.Fatalf("test case #%d %q: invalid duration", i, tc)
- }
- now = time.Unix(0, 0).Add(time.Duration(d) * time.Second)
-
- case "want":
- m.mu.Lock()
- m.collectExpiredNodes(now)
- got := make([]string, 0, len(m.byToken))
- for _, n := range m.byToken {
- got = append(got, fmt.Sprintf("%s.%d",
- n.details.Root, n.expiry.Sub(zTime)/time.Second))
- }
- m.mu.Unlock()
- sort.Strings(got)
- want := []string{}
- if arg != "" {
- want = strings.Split(arg, " ")
- }
- if !reflect.DeepEqual(got, want) {
- t.Fatalf("test case #%d %q:\ngot %q\nwant %q", i, tc, got, want)
- }
- }
-
- if err := m.consistent(); err != nil {
- t.Fatalf("test case #%d %q: inconsistent state: %v", i, tc, err)
- }
- }
-}
-
-func TestMemLS(t *testing.T) {
- now := time.Unix(0, 0)
- m := NewMemLS().(*memLS)
- rng := rand.New(rand.NewSource(0))
- tokens := map[string]string{}
- nConfirm, nCreate, nRefresh, nUnlock := 0, 0, 0, 0
- const N = 2000
-
- for i := 0; i < N; i++ {
- name := lockTestNames[rng.Intn(len(lockTestNames))]
- duration := lockTestDurations[rng.Intn(len(lockTestDurations))]
- confirmed, unlocked := false, false
-
- // If the name was already locked, we randomly confirm/release, refresh
- // or unlock it. Otherwise, we create a lock.
- token := tokens[name]
- if token != "" {
- switch rng.Intn(3) {
- case 0:
- confirmed = true
- nConfirm++
- release, err := m.Confirm(now, name, "", Condition{Token: token})
- if err != nil {
- t.Fatalf("iteration #%d: Confirm %q: %v", i, name, err)
- }
- if err := m.consistent(); err != nil {
- t.Fatalf("iteration #%d: inconsistent state: %v", i, err)
- }
- release()
-
- case 1:
- nRefresh++
- if _, err := m.Refresh(now, token, duration); err != nil {
- t.Fatalf("iteration #%d: Refresh %q: %v", i, name, err)
- }
-
- case 2:
- unlocked = true
- nUnlock++
- if err := m.Unlock(now, token); err != nil {
- t.Fatalf("iteration #%d: Unlock %q: %v", i, name, err)
- }
- }
-
- } else {
- nCreate++
- var err error
- token, err = m.Create(now, LockDetails{
- Root: name,
- Duration: duration,
- ZeroDepth: lockTestZeroDepth(name),
- })
- if err != nil {
- t.Fatalf("iteration #%d: Create %q: %v", i, name, err)
- }
- }
-
- if !confirmed {
- if duration == 0 || unlocked {
- // A zero-duration lock should expire immediately and is
- // effectively equivalent to being unlocked.
- tokens[name] = ""
- } else {
- tokens[name] = token
- }
- }
-
- if err := m.consistent(); err != nil {
- t.Fatalf("iteration #%d: inconsistent state: %v", i, err)
- }
- }
-
- if nConfirm < N/10 {
- t.Fatalf("too few Confirm calls: got %d, want >= %d", nConfirm, N/10)
- }
- if nCreate < N/10 {
- t.Fatalf("too few Create calls: got %d, want >= %d", nCreate, N/10)
- }
- if nRefresh < N/10 {
- t.Fatalf("too few Refresh calls: got %d, want >= %d", nRefresh, N/10)
- }
- if nUnlock < N/10 {
- t.Fatalf("too few Unlock calls: got %d, want >= %d", nUnlock, N/10)
- }
-}
-
-func (m *memLS) consistent() error {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- // If m.byName is non-empty, then it must contain an entry for the root "/",
- // and its refCount should equal the number of locked nodes.
- if len(m.byName) > 0 {
- n := m.byName["/"]
- if n == nil {
- return fmt.Errorf(`non-empty m.byName does not contain the root "/"`)
- }
- if n.refCount != len(m.byToken) {
- return fmt.Errorf("root node refCount=%d, differs from len(m.byToken)=%d", n.refCount, len(m.byToken))
- }
- }
-
- for name, n := range m.byName {
- // The map keys should be consistent with the node's copy of the key.
- if n.details.Root != name {
- return fmt.Errorf("node name %q != byName map key %q", n.details.Root, name)
- }
-
- // A name must be clean, and start with a "/".
- if len(name) == 0 || name[0] != '/' {
- return fmt.Errorf(`node name %q does not start with "/"`, name)
- }
- if name != path.Clean(name) {
- return fmt.Errorf(`node name %q is not clean`, name)
- }
-
- // A node's refCount should be positive.
- if n.refCount <= 0 {
- return fmt.Errorf("non-positive refCount for node at name %q", name)
- }
-
- // A node's refCount should be the number of self-or-descendents that
- // are locked (i.e. have a non-empty token).
- var list []string
- for name0, n0 := range m.byName {
- // All of lockTestNames' name fragments are one byte long: '_', 'i' or 'z',
- // so strings.HasPrefix is equivalent to self-or-descendent name match.
- // We don't have to worry about "/foo/bar" being a false positive match
- // for "/foo/b".
- if strings.HasPrefix(name0, name) && n0.token != "" {
- list = append(list, name0)
- }
- }
- if n.refCount != len(list) {
- sort.Strings(list)
- return fmt.Errorf("node at name %q has refCount %d but locked self-or-descendents are %q (len=%d)",
- name, n.refCount, list, len(list))
- }
-
- // A node n is in m.byToken if it has a non-empty token.
- if n.token != "" {
- if _, ok := m.byToken[n.token]; !ok {
- return fmt.Errorf("node at name %q has token %q but not in m.byToken", name, n.token)
- }
- }
-
- // A node n is in m.byExpiry if it has a non-negative byExpiryIndex.
- if n.byExpiryIndex >= 0 {
- if n.byExpiryIndex >= len(m.byExpiry) {
- return fmt.Errorf("node at name %q has byExpiryIndex %d but m.byExpiry has length %d", name, n.byExpiryIndex, len(m.byExpiry))
- }
- if n != m.byExpiry[n.byExpiryIndex] {
- return fmt.Errorf("node at name %q has byExpiryIndex %d but that indexes a different node", name, n.byExpiryIndex)
- }
- }
- }
-
- for token, n := range m.byToken {
- // The map keys should be consistent with the node's copy of the key.
- if n.token != token {
- return fmt.Errorf("node token %q != byToken map key %q", n.token, token)
- }
-
- // Every node in m.byToken is in m.byName.
- if _, ok := m.byName[n.details.Root]; !ok {
- return fmt.Errorf("node at name %q in m.byToken but not in m.byName", n.details.Root)
- }
- }
-
- for i, n := range m.byExpiry {
- // The slice indices should be consistent with the node's copy of the index.
- if n.byExpiryIndex != i {
- return fmt.Errorf("node byExpiryIndex %d != byExpiry slice index %d", n.byExpiryIndex, i)
- }
-
- // Every node in m.byExpiry is in m.byName.
- if _, ok := m.byName[n.details.Root]; !ok {
- return fmt.Errorf("node at name %q in m.byExpiry but not in m.byName", n.details.Root)
- }
-
- // No node in m.byExpiry should be held.
- if n.held {
- return fmt.Errorf("node at name %q in m.byExpiry is held", n.details.Root)
- }
- }
- return nil
-}
-
-func TestParseTimeout(t *testing.T) {
- testCases := []struct {
- s string
- want time.Duration
- wantErr error
- }{{
- "",
- infiniteTimeout,
- nil,
- }, {
- "Infinite",
- infiniteTimeout,
- nil,
- }, {
- "Infinitesimal",
- 0,
- errInvalidTimeout,
- }, {
- "infinite",
- 0,
- errInvalidTimeout,
- }, {
- "Second-0",
- 0 * time.Second,
- nil,
- }, {
- "Second-123",
- 123 * time.Second,
- nil,
- }, {
- " Second-456 ",
- 456 * time.Second,
- nil,
- }, {
- "Second-4100000000",
- 4100000000 * time.Second,
- nil,
- }, {
- "junk",
- 0,
- errInvalidTimeout,
- }, {
- "Second-",
- 0,
- errInvalidTimeout,
- }, {
- "Second--1",
- 0,
- errInvalidTimeout,
- }, {
- "Second--123",
- 0,
- errInvalidTimeout,
- }, {
- "Second-+123",
- 0,
- errInvalidTimeout,
- }, {
- "Second-0x123",
- 0,
- errInvalidTimeout,
- }, {
- "second-123",
- 0,
- errInvalidTimeout,
- }, {
- "Second-4294967295",
- 4294967295 * time.Second,
- nil,
- }, {
- // Section 10.7 says that "The timeout value for TimeType "Second"
- // must not be greater than 2^32-1."
- "Second-4294967296",
- 0,
- errInvalidTimeout,
- }, {
- // This test case comes from section 9.10.9 of the spec. It says,
- //
- // "In this request, the client has specified that it desires an
- // infinite-length lock, if available, otherwise a timeout of 4.1
- // billion seconds, if available."
- //
- // The Go WebDAV package always supports infinite length locks,
- // and ignores the fallback after the comma.
- "Infinite, Second-4100000000",
- infiniteTimeout,
- nil,
- }}
-
- for _, tc := range testCases {
- got, gotErr := parseTimeout(tc.s)
- if got != tc.want || gotErr != tc.wantErr {
- t.Errorf("parsing %q:\ngot %v, %v\nwant %v, %v", tc.s, got, gotErr, tc.want, tc.wantErr)
- }
- }
-}