lfs/pointer_test.go

   1 package lfs
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "io/ioutil"
   7         "reflect"
   8         "strings"
   9         "testing"
  10
  11         "github.com/git-lfs/git-lfs/errors"
  12         "github.com/stretchr/testify/assert"
  13 )
  14
  15 func TestEncode(t *testing.T) {
  16         var buf bytes.Buffer
  17         pointer := NewPointer("booya", 12345, nil)
  18         _, err := EncodePointer(&buf, pointer)
  19         assert.Nil(t, err)
  20
  21         bufReader := bufio.NewReader(&buf)
  22         assertLine(t, bufReader, "version https://git-lfs.github.com/spec/v1\n")
  23         assertLine(t, bufReader, "oid sha256:booya\n")
  24         assertLine(t, bufReader, "size 12345\n")
  25
  26         line, err := bufReader.ReadString('\n')
  27         if err == nil {
  28                 t.Fatalf("More to read: %s", line)
  29         }
  30         assert.Equal(t, "EOF", err.Error())
  31 }
  32
  33 func TestEncodeEmpty(t *testing.T) {
  34         var buf bytes.Buffer
  35         pointer := NewPointer("", 0, nil)
  36         _, err := EncodePointer(&buf, pointer)
  37         assert.Equal(t, nil, err)
  38
  39         bufReader := bufio.NewReader(&buf)
  40         val, err := bufReader.ReadString('\n')
  41         assert.Equal(t, "", val)
  42         assert.Equal(t, "EOF", err.Error())
  43 }
  44
  45 func TestEncodeExtensions(t *testing.T) {
  46         var buf bytes.Buffer
  47         exts := []*PointerExtension{
  48                 NewPointerExtension("foo", 0, "foo_oid"),
  49                 NewPointerExtension("bar", 1, "bar_oid"),
  50                 NewPointerExtension("baz", 2, "baz_oid"),
  51         }
  52         pointer := NewPointer("main_oid", 12345, exts)
  53         _, err := EncodePointer(&buf, pointer)
  54         assert.Nil(t, err)
  55
  56         bufReader := bufio.NewReader(&buf)
  57         assertLine(t, bufReader, "version https://git-lfs.github.com/spec/v1\n")
  58         assertLine(t, bufReader, "ext-0-foo sha256:foo_oid\n")
  59         assertLine(t, bufReader, "ext-1-bar sha256:bar_oid\n")
  60         assertLine(t, bufReader, "ext-2-baz sha256:baz_oid\n")
  61         assertLine(t, bufReader, "oid sha256:main_oid\n")
  62         assertLine(t, bufReader, "size 12345\n")
  63
  64         line, err := bufReader.ReadString('\n')
  65         if err == nil {
  66                 t.Fatalf("More to read: %s", line)
  67         }
  68         assert.Equal(t, "EOF", err.Error())
  69 }
  70
  71 func assertLine(t *testing.T, r *bufio.Reader, expected string) {
  72         actual, err := r.ReadString('\n')
  73         assert.Nil(t, err)
  74         assert.Equal(t, expected, actual)
  75 }
  76
  77 func TestDecodeTinyFile(t *testing.T) {
  78         ex := "this is not a git-lfs file!"
  79         p, err := DecodePointer(bytes.NewBufferString(ex))
  80         if p != nil {
  81                 t.Errorf("pointer was decoded: %v", p)
  82         }
  83
  84         if !errors.IsNotAPointerError(err) {
  85                 t.Errorf("error is not a NotAPointerError: %s: '%v'", reflect.TypeOf(err), err)
  86         }
  87 }
  88
  89 func TestDecode(t *testing.T) {
  90         ex := `version https://git-lfs.github.com/spec/v1
  91 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
  92 size 12345`
  93
  94         p, err := DecodePointer(bytes.NewBufferString(ex))
  95         assertEqualWithExample(t, ex, nil, err)
  96         assertEqualWithExample(t, ex, latest, p.Version)
  97         assertEqualWithExample(t, ex, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
  98         assertEqualWithExample(t, ex, "sha256", p.OidType)
  99         assertEqualWithExample(t, ex, int64(12345), p.Size)
 100 }
 101
 102 func TestDecodeExtensions(t *testing.T) {
 103         ex := `version https://git-lfs.github.com/spec/v1
 104 ext-0-foo sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 105 ext-1-bar sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
 106 ext-2-baz sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 107 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 108 size 12345`
 109
 110         p, err := DecodePointer(bytes.NewBufferString(ex))
 111         assertEqualWithExample(t, ex, nil, err)
 112         assertEqualWithExample(t, ex, latest, p.Version)
 113         assertEqualWithExample(t, ex, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 114         assertEqualWithExample(t, ex, int64(12345), p.Size)
 115         assertEqualWithExample(t, ex, "sha256", p.OidType)
 116         assertEqualWithExample(t, ex, "foo", p.Extensions[0].Name)
 117         assertEqualWithExample(t, ex, 0, p.Extensions[0].Priority)
 118         assertEqualWithExample(t, ex, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", p.Extensions[0].Oid)
 119         assertEqualWithExample(t, ex, "sha256", p.Extensions[0].OidType)
 120         assertEqualWithExample(t, ex, "bar", p.Extensions[1].Name)
 121         assertEqualWithExample(t, ex, 1, p.Extensions[1].Priority)
 122         assertEqualWithExample(t, ex, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", p.Extensions[1].Oid)
 123         assertEqualWithExample(t, ex, "sha256", p.Extensions[1].OidType)
 124         assertEqualWithExample(t, ex, "baz", p.Extensions[2].Name)
 125         assertEqualWithExample(t, ex, 2, p.Extensions[2].Priority)
 126         assertEqualWithExample(t, ex, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", p.Extensions[2].Oid)
 127         assertEqualWithExample(t, ex, "sha256", p.Extensions[2].OidType)
 128 }
 129
 130 func TestDecodeExtensionsSort(t *testing.T) {
 131         ex := `version https://git-lfs.github.com/spec/v1
 132 ext-2-baz sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 133 ext-0-foo sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 134 ext-1-bar sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
 135 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 136 size 12345`
 137
 138         p, err := DecodePointer(bytes.NewBufferString(ex))
 139         assertEqualWithExample(t, ex, nil, err)
 140         assertEqualWithExample(t, ex, latest, p.Version)
 141         assertEqualWithExample(t, ex, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 142         assertEqualWithExample(t, ex, int64(12345), p.Size)
 143         assertEqualWithExample(t, ex, "sha256", p.OidType)
 144         assertEqualWithExample(t, ex, "foo", p.Extensions[0].Name)
 145         assertEqualWithExample(t, ex, 0, p.Extensions[0].Priority)
 146         assertEqualWithExample(t, ex, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", p.Extensions[0].Oid)
 147         assertEqualWithExample(t, ex, "sha256", p.Extensions[0].OidType)
 148         assertEqualWithExample(t, ex, "bar", p.Extensions[1].Name)
 149         assertEqualWithExample(t, ex, 1, p.Extensions[1].Priority)
 150         assertEqualWithExample(t, ex, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", p.Extensions[1].Oid)
 151         assertEqualWithExample(t, ex, "sha256", p.Extensions[1].OidType)
 152         assertEqualWithExample(t, ex, "baz", p.Extensions[2].Name)
 153         assertEqualWithExample(t, ex, 2, p.Extensions[2].Priority)
 154         assertEqualWithExample(t, ex, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", p.Extensions[2].Oid)
 155         assertEqualWithExample(t, ex, "sha256", p.Extensions[2].OidType)
 156 }
 157
 158 func TestDecodePreRelease(t *testing.T) {
 159         ex := `version https://hawser.github.com/spec/v1
 160 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 161 size 12345`
 162
 163         p, err := DecodePointer(bytes.NewBufferString(ex))
 164         assertEqualWithExample(t, ex, nil, err)
 165         assertEqualWithExample(t, ex, latest, p.Version)
 166         assertEqualWithExample(t, ex, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 167         assertEqualWithExample(t, ex, "sha256", p.OidType)
 168         assertEqualWithExample(t, ex, int64(12345), p.Size)
 169 }
 170
 171 func TestDecodeFromEmptyReader(t *testing.T) {
 172         p, buf, err := DecodeFrom(strings.NewReader(""))
 173         by, rerr := ioutil.ReadAll(buf)
 174
 175         assert.Nil(t, rerr)
 176         assert.EqualError(t, err, "Pointer file error: invalid header")
 177         assert.Nil(t, p)
 178         assert.Empty(t, by)
 179 }
 180
 181 func TestDecodeInvalid(t *testing.T) {
 182         examples := []string{
 183                 "invalid stuff",
 184
 185                 // no sha
 186                 "# git-media",
 187
 188                 // bad oid
 189                 `version https://git-lfs.github.com/spec/v1
 190 oid sha256:boom
 191 size 12345`,
 192
 193                 // bad oid type
 194                 `version https://git-lfs.github.com/spec/v1
 195 oid shazam:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 196 size 12345`,
 197
 198                 // no oid
 199                 `version https://git-lfs.github.com/spec/v1
 200 size 12345`,
 201
 202                 // bad version
 203                 `version http://git-media.io/v/whatever
 204 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 205 size 12345`,
 206
 207                 // no version
 208                 `oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 209 size 12345`,
 210
 211                 // bad size
 212                 `version https://git-lfs.github.com/spec/v1
 213 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 214 size fif`,
 215
 216                 // no size
 217                 `version https://git-lfs.github.com/spec/v1
 218 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393`,
 219
 220                 // bad `key value` format
 221                 `version=https://git-lfs.github.com/spec/v1
 222 oid=sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 223 size=fif`,
 224
 225                 // no git-media
 226                 `version=http://wat.io/v/2
 227 oid=sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 228 size=fif`,
 229
 230                 // extra key
 231                 `version https://git-lfs.github.com/spec/v1
 232 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 233 size 12345
 234 wat wat`,
 235
 236                 // keys out of order
 237                 `version https://git-lfs.github.com/spec/v1
 238 size 12345
 239 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393`,
 240
 241                 // bad ext name
 242                 `version https://git-lfs.github.com/spec/v1
 243 ext-0-$$$$ sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 244 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 245 size 12345`,
 246
 247                 // bad ext priority
 248                 `version https://git-lfs.github.com/spec/v1
 249 ext-#-foo sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 250 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 251 size 12345`,
 252
 253                 // duplicate ext priority
 254                 `version https://git-lfs.github.com/spec/v1
 255 ext-0-foo sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 256 ext-0-bar sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
 257 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 258 size 12345`,
 259
 260                 // ext priority over 9
 261                 `version https://git-lfs.github.com/spec/v1
 262 ext-10-foo sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 263 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 264 size 12345`,
 265
 266                 // bad ext oid
 267                 `version https://git-lfs.github.com/spec/v1
 268 ext-0-foo sha256:boom
 269 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 270 size 12345`,
 271
 272                 // bad ext oid type
 273                 `version https://git-lfs.github.com/spec/v1
 274 ext-0-foo boom:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 275 oid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393
 276 size 12345`,
 277         }
 278
 279         for _, ex := range examples {
 280                 p, err := DecodePointer(bytes.NewBufferString(ex))
 281                 if err == nil {
 282                         t.Errorf("No error decoding: %v\nFrom:\n%s", p, strings.TrimSpace(ex))
 283                 }
 284         }
 285 }
 286
 287 func assertEqualWithExample(t *testing.T, example string, expected, actual interface{}) {
 288         assert.Equal(t, expected, actual, "Example:\n%s", strings.TrimSpace(example))
 289 }