kraken

1
// Copyright (c) 2016-2019 Uber Technologies, Inc.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
package core
15

16
import (
17
	"encoding/json"
18
	"fmt"
19
	"testing"
20

21
	"github.com/stretchr/testify/require"
22
)
23

24
func TestValidateSHA256(t *testing.T) {
25
	tests := []struct {
26
		desc  string
27
		input string
28
		err   bool
29
	}{
30
		{"valid", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", false},
31
		{"too short", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85", true},
32
		{"too long", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b8556", true},
33
		{"invalid hex", "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", true},
34
	}
35
	for _, test := range tests {
36
		t.Run(test.desc, func(t *testing.T) {
37
			err := ValidateSHA256(test.input)
38
			if test.err {
39
				require.Error(t, err)
40
			} else {
41
				require.NoError(t, err)
42
			}
43
		})
44
	}
45
}
46

47
func TestNewSHA256DigestFromHex(t *testing.T) {
48
	require := require.New(t)
49

50
	d, err := NewSHA256DigestFromHex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
51
	require.NoError(err)
52
	require.Equal("sha256", d.Algo())
53
	require.Equal("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", d.Hex())
54
	require.Equal("sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", d.String())
55
	v, err := d.Value()
56
	require.NoError(err)
57
	require.Equal([]byte("\"sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\""), v)
58
	require.Equal("e3b0", d.ShardID())
59
}
60

61
func TestNewSHA256DigestFromHexError(t *testing.T) {
62
	_, err := NewSHA256DigestFromHex("invalid")
63
	require.Error(t, err)
64
}
65

66
func TestParseSHA256Digest(t *testing.T) {
67
	require := require.New(t)
68

69
	d, err := ParseSHA256Digest("sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
70
	require.NoError(err)
71
	require.Equal("sha256", d.Algo())
72
	require.Equal("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", d.Hex())
73
	require.Equal("sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", d.String())
74
	v, err := d.Value()
75
	require.NoError(err)
76
	require.Equal([]byte("\"sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\""), v)
77
	require.Equal("e3b0", d.ShardID())
78
}
79

80
func TestParseSHA256DigestErrors(t *testing.T) {
81
	tests := []struct {
82
		desc  string
83
		input string
84
	}{
85
		{"empty", ""},
86
		{"extra part", "sha256:sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
87
		{"no algo", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
88
		{"wrong algo", "sha1:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
89
		{"invalid hex", "sha256:invalid"},
90
	}
91
	for _, test := range tests {
92
		t.Run(test.desc, func(t *testing.T) {
93
			_, err := ParseSHA256Digest(test.input)
94
			require.Error(t, err)
95
		})
96
	}
97
}
98

99
func TestDigestStringConversion(t *testing.T) {
100
	d := DigestFixture()
101
	result, err := ParseSHA256Digest(d.String())
102
	require.NoError(t, err)
103
	require.Equal(t, d, result)
104
}
105

106
func TestDigestMarshalJSON(t *testing.T) {
107
	require := require.New(t)
108
	digest := DigestFixture()
109

110
	b, err := json.Marshal(digest)
111
	require.NoError(err)
112
	require.Equal(string(b), fmt.Sprintf("%q", digest))
113

114
	var result Digest
115
	require.NoError(json.Unmarshal(b, &result))
116
	require.Equal(digest, result)
117
}
118

119
func TestDigestUnmarshalJSONErrors(t *testing.T) {
120
	tests := []struct {
121
		desc  string
122
		input string
123
	}{
124
		{"empty", ""},
125
		{"invalid", "\"sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
126
		{"no algo", "\"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\""},
127
	}
128
	for _, test := range tests {
129
		t.Run(test.desc, func(t *testing.T) {
130
			var d Digest
131
			require.Error(t, d.UnmarshalJSON([]byte(test.input)))
132
		})
133
	}
134
}
135

136
func TestDigestListValue(t *testing.T) {
137
	require := require.New(t)
138
	digests := DigestList{DigestFixture(), DigestFixture(), DigestFixture()}
139
	v, err := digests.Value()
140
	require.NoError(err)
141
	expected := fmt.Sprintf("[%q,%q,%q]", digests[0], digests[1], digests[2])
142
	require.Equal(expected, fmt.Sprintf("%s", v))
143

144
	var result DigestList
145
	require.NoError(result.Scan([]byte(expected)))
146
	require.Equal(digests, result)
147
}
148