mirror of
https://github.com/Luzifer/nginx-sso.git
synced 2024-12-20 21:01:17 +00:00
122 lines
2.9 KiB
Go
122 lines
2.9 KiB
Go
/*-
|
|
* Copyright 2014 Square Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package jose
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestDeflateRoundtrip(t *testing.T) {
|
|
original := []byte("Lorem ipsum dolor sit amet")
|
|
|
|
compressed, err := deflate(original)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
output, err := inflate(compressed)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if bytes.Compare(output, original) != 0 {
|
|
t.Error("Input and output do not match")
|
|
}
|
|
}
|
|
|
|
func TestInvalidCompression(t *testing.T) {
|
|
_, err := compress("XYZ", []byte{})
|
|
if err == nil {
|
|
t.Error("should not accept invalid algorithm")
|
|
}
|
|
|
|
_, err = decompress("XYZ", []byte{})
|
|
if err == nil {
|
|
t.Error("should not accept invalid algorithm")
|
|
}
|
|
|
|
_, err = decompress(DEFLATE, []byte{1, 2, 3, 4})
|
|
if err == nil {
|
|
t.Error("should not accept invalid data")
|
|
}
|
|
}
|
|
|
|
func TestByteBufferTrim(t *testing.T) {
|
|
buf := newBufferFromInt(1)
|
|
if !bytes.Equal(buf.data, []byte{1}) {
|
|
t.Error("Byte buffer for integer '1' should contain [0x01]")
|
|
}
|
|
|
|
buf = newBufferFromInt(65537)
|
|
if !bytes.Equal(buf.data, []byte{1, 0, 1}) {
|
|
t.Error("Byte buffer for integer '65537' should contain [0x01, 0x00, 0x01]")
|
|
}
|
|
}
|
|
|
|
func TestFixedSizeBuffer(t *testing.T) {
|
|
data0 := []byte{}
|
|
data1 := []byte{1}
|
|
data2 := []byte{1, 2}
|
|
data3 := []byte{1, 2, 3}
|
|
data4 := []byte{1, 2, 3, 4}
|
|
|
|
buf0 := newFixedSizeBuffer(data0, 4)
|
|
buf1 := newFixedSizeBuffer(data1, 4)
|
|
buf2 := newFixedSizeBuffer(data2, 4)
|
|
buf3 := newFixedSizeBuffer(data3, 4)
|
|
buf4 := newFixedSizeBuffer(data4, 4)
|
|
|
|
if !bytes.Equal(buf0.data, []byte{0, 0, 0, 0}) {
|
|
t.Error("Invalid padded buffer for buf0")
|
|
}
|
|
if !bytes.Equal(buf1.data, []byte{0, 0, 0, 1}) {
|
|
t.Error("Invalid padded buffer for buf1")
|
|
}
|
|
if !bytes.Equal(buf2.data, []byte{0, 0, 1, 2}) {
|
|
t.Error("Invalid padded buffer for buf2")
|
|
}
|
|
if !bytes.Equal(buf3.data, []byte{0, 1, 2, 3}) {
|
|
t.Error("Invalid padded buffer for buf3")
|
|
}
|
|
if !bytes.Equal(buf4.data, []byte{1, 2, 3, 4}) {
|
|
t.Error("Invalid padded buffer for buf4")
|
|
}
|
|
}
|
|
|
|
func TestSerializeJSONRejectsNil(t *testing.T) {
|
|
defer func() {
|
|
r := recover()
|
|
if r == nil || !strings.Contains(r.(string), "nil pointer") {
|
|
t.Error("serialize function should not accept nil pointer")
|
|
}
|
|
}()
|
|
|
|
mustSerializeJSON(nil)
|
|
}
|
|
|
|
func TestFixedSizeBufferTooLarge(t *testing.T) {
|
|
defer func() {
|
|
r := recover()
|
|
if r == nil {
|
|
t.Error("should not be able to create fixed size buffer with oversized data")
|
|
}
|
|
}()
|
|
|
|
newFixedSizeBuffer(make([]byte, 2), 1)
|
|
}
|