github.com/psexton/git-lfs@v2.1.1-0.20170517224304-289a18b2bc53+incompatible/locking/locks_test.go (about)

     1  package locking
     2  
     3  import (
     4  	"encoding/json"
     5  	"io/ioutil"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"sort"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/git-lfs/git-lfs/lfsapi"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  type LocksById []Lock
    18  
    19  func (a LocksById) Len() int           { return len(a) }
    20  func (a LocksById) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
    21  func (a LocksById) Less(i, j int) bool { return a[i].Id < a[j].Id }
    22  
    23  func TestRefreshCache(t *testing.T) {
    24  	var err error
    25  	tempDir, err := ioutil.TempDir("", "testCacheLock")
    26  	assert.Nil(t, err)
    27  
    28  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    29  		assert.Equal(t, "POST", r.Method)
    30  		assert.Equal(t, "/api/locks/verify", r.URL.Path)
    31  
    32  		w.Header().Set("Content-Type", "application/json")
    33  		err = json.NewEncoder(w).Encode(lockVerifiableList{
    34  			Theirs: []Lock{
    35  				Lock{Id: "99", Path: "folder/test3.dat", Owner: &User{Name: "Alice"}},
    36  				Lock{Id: "199", Path: "other/test1.dat", Owner: &User{Name: "Charles"}},
    37  			},
    38  			Ours: []Lock{
    39  				Lock{Id: "101", Path: "folder/test1.dat", Owner: &User{Name: "Fred"}},
    40  				Lock{Id: "102", Path: "folder/test2.dat", Owner: &User{Name: "Fred"}},
    41  				Lock{Id: "103", Path: "root.dat", Owner: &User{Name: "Fred"}},
    42  			},
    43  		})
    44  		assert.Nil(t, err)
    45  	}))
    46  
    47  	defer func() {
    48  		srv.Close()
    49  	}()
    50  
    51  	lfsclient, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
    52  		"lfs.url":    srv.URL + "/api",
    53  		"user.name":  "Fred",
    54  		"user.email": "fred@bloggs.com",
    55  	}))
    56  	require.Nil(t, err)
    57  
    58  	client, err := NewClient("", lfsclient)
    59  	assert.Nil(t, err)
    60  	assert.Nil(t, client.SetupFileCache(tempDir))
    61  
    62  	// Should start with no cached items
    63  	locks, err := client.SearchLocks(nil, 0, true)
    64  	assert.Nil(t, err)
    65  	assert.Empty(t, locks)
    66  
    67  	// Should load from test data, just Fred's
    68  	err = client.refreshLockCache()
    69  	assert.Nil(t, err)
    70  
    71  	locks, err = client.SearchLocks(nil, 0, true)
    72  	assert.Nil(t, err)
    73  	// Need to include zero time in structure for equal to work
    74  	zeroTime := time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC)
    75  
    76  	// Sort locks for stable comparison
    77  	sort.Sort(LocksById(locks))
    78  	assert.Equal(t, []Lock{
    79  		Lock{Path: "folder/test1.dat", Id: "101", Owner: &User{Name: "Fred"}, LockedAt: zeroTime},
    80  		Lock{Path: "folder/test2.dat", Id: "102", Owner: &User{Name: "Fred"}, LockedAt: zeroTime},
    81  		Lock{Path: "root.dat", Id: "103", Owner: &User{Name: "Fred"}, LockedAt: zeroTime},
    82  	}, locks)
    83  }
    84  
    85  func TestGetVerifiableLocks(t *testing.T) {
    86  	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    87  		assert.Equal(t, "POST", r.Method)
    88  		assert.Equal(t, "/api/locks/verify", r.URL.Path)
    89  
    90  		body := lockVerifiableRequest{}
    91  		if assert.Nil(t, json.NewDecoder(r.Body).Decode(&body)) {
    92  			w.Header().Set("Content-Type", "application/json")
    93  			list := lockVerifiableList{}
    94  			if body.Cursor == "1" {
    95  				list.Ours = []Lock{
    96  					Lock{Path: "folder/1/test1.dat", Id: "111"},
    97  				}
    98  				list.Theirs = []Lock{
    99  					Lock{Path: "folder/1/test2.dat", Id: "112"},
   100  					Lock{Path: "folder/1/test3.dat", Id: "113"},
   101  				}
   102  			} else {
   103  				list.Ours = []Lock{
   104  					Lock{Path: "folder/0/test1.dat", Id: "101"},
   105  					Lock{Path: "folder/0/test2.dat", Id: "102"},
   106  				}
   107  				list.Theirs = []Lock{
   108  					Lock{Path: "folder/0/test3.dat", Id: "103"},
   109  				}
   110  				list.NextCursor = "1"
   111  			}
   112  
   113  			err := json.NewEncoder(w).Encode(&list)
   114  			assert.Nil(t, err)
   115  		} else {
   116  			w.WriteHeader(500)
   117  		}
   118  	}))
   119  
   120  	defer srv.Close()
   121  
   122  	lfsclient, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
   123  		"lfs.url":    srv.URL + "/api",
   124  		"user.name":  "Fred",
   125  		"user.email": "fred@bloggs.com",
   126  	}))
   127  	require.Nil(t, err)
   128  
   129  	client, err := NewClient("", lfsclient)
   130  	assert.Nil(t, err)
   131  
   132  	ourLocks, theirLocks, err := client.VerifiableLocks(0)
   133  	assert.Nil(t, err)
   134  
   135  	// Need to include zero time in structure for equal to work
   136  	zeroTime := time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC)
   137  
   138  	// Sort locks for stable comparison
   139  	sort.Sort(LocksById(ourLocks))
   140  	assert.Equal(t, []Lock{
   141  		Lock{Path: "folder/0/test1.dat", Id: "101", LockedAt: zeroTime},
   142  		Lock{Path: "folder/0/test2.dat", Id: "102", LockedAt: zeroTime},
   143  		Lock{Path: "folder/1/test1.dat", Id: "111", LockedAt: zeroTime},
   144  	}, ourLocks)
   145  
   146  	sort.Sort(LocksById(theirLocks))
   147  	assert.Equal(t, []Lock{
   148  		Lock{Path: "folder/0/test3.dat", Id: "103", LockedAt: zeroTime},
   149  		Lock{Path: "folder/1/test2.dat", Id: "112", LockedAt: zeroTime},
   150  		Lock{Path: "folder/1/test3.dat", Id: "113", LockedAt: zeroTime},
   151  	}, theirLocks)
   152  }