zitadel/internal/crypto/crypto_test.go

package crypto

import (
	"bytes"
	"errors"
	"reflect"
	"testing"
)

type mockEncCrypto struct {
}

func (m *mockEncCrypto) Algorithm() string {
	return "enc"
}

func (m *mockEncCrypto) Encrypt(value []byte) ([]byte, error) {
	return value, nil
}

func (m *mockEncCrypto) Decrypt(value []byte, _ string) ([]byte, error) {
	return value, nil
}

func (m *mockEncCrypto) DecryptString(value []byte, _ string) (string, error) {
	return string(value), nil
}

func (m *mockEncCrypto) EncryptionKeyID() string {
	return "keyID"
}
func (m *mockEncCrypto) DecryptionKeyIDs() []string {
	return []string{"keyID"}
}

type mockHashCrypto struct {
}

func (m *mockHashCrypto) Algorithm() string {
	return "hash"
}

func (m *mockHashCrypto) Hash(value []byte) ([]byte, error) {
	return value, nil
}

func (m *mockHashCrypto) CompareHash(hashed, comparer []byte) error {
	if !bytes.Equal(hashed, comparer) {
		return errors.New("not equal")
	}
	return nil
}

type alg struct{}

func (a *alg) Algorithm() string {
	return "alg"
}

func TestCrypt(t *testing.T) {
	type args struct {
		value []byte
		c     Crypto
	}
	tests := []struct {
		name    string
		args    args
		want    *CryptoValue
		wantErr bool
	}{
		{
			"encrypt",
			args{[]byte("test"), &mockEncCrypto{}},
			&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID", Crypted: []byte("test")},
			false,
		},
		{
			"hash",
			args{[]byte("test"), &mockHashCrypto{}},
			&CryptoValue{CryptoType: TypeHash, Algorithm: "hash", Crypted: []byte("test")},
			false,
		},
		{
			"wrong type",
			args{[]byte("test"), &alg{}},
			nil,
			true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := Crypt(tt.args.value, tt.args.c)
			if (err != nil) != tt.wantErr {
				t.Errorf("Crypt() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Crypt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestEncrypt(t *testing.T) {
	type args struct {
		value []byte
		c     EncryptionAlgorithm
	}
	tests := []struct {
		name    string
		args    args
		want    *CryptoValue
		wantErr bool
	}{
		{
			"ok",
			args{[]byte("test"), &mockEncCrypto{}},
			&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID", Crypted: []byte("test")},
			false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := Encrypt(tt.args.value, tt.args.c)
			if (err != nil) != tt.wantErr {
				t.Errorf("Encrypt() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Encrypt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecrypt(t *testing.T) {
	type args struct {
		value *CryptoValue
		c     EncryptionAlgorithm
	}
	tests := []struct {
		name    string
		args    args
		want    []byte
		wantErr bool
	}{
		{
			"ok",
			args{&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID", Crypted: []byte("test")}, &mockEncCrypto{}},
			[]byte("test"),
			false,
		},
		{
			"wrong id",
			args{&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID2", Crypted: []byte("test")}, &mockEncCrypto{}},
			nil,
			true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := Decrypt(tt.args.value, tt.args.c)
			if (err != nil) != tt.wantErr {
				t.Errorf("Decrypt() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Decrypt() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecryptString(t *testing.T) {
	type args struct {
		value *CryptoValue
		c     EncryptionAlgorithm
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		{
			"ok",
			args{&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID", Crypted: []byte("test")}, &mockEncCrypto{}},
			"test",
			false,
		},
		{
			"wrong id",
			args{&CryptoValue{CryptoType: TypeEncryption, Algorithm: "enc", KeyID: "keyID2", Crypted: []byte("test")}, &mockEncCrypto{}},
			"",
			true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := DecryptString(tt.args.value, tt.args.c)
			if (err != nil) != tt.wantErr {
				t.Errorf("DecryptString() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("DecryptString() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestHash(t *testing.T) {
	type args struct {
		value []byte
		c     HashAlgorithm
	}
	tests := []struct {
		name    string
		args    args
		want    *CryptoValue
		wantErr bool
	}{
		{
			"ok",
			args{[]byte("test"), &mockHashCrypto{}},
			&CryptoValue{CryptoType: TypeHash, Algorithm: "hash", Crypted: []byte("test")},
			false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := Hash(tt.args.value, tt.args.c)
			if (err != nil) != tt.wantErr {
				t.Errorf("Hash() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Hash() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCompareHash(t *testing.T) {
	type args struct {
		value    *CryptoValue
		comparer []byte
		c        HashAlgorithm
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			"ok",
			args{&CryptoValue{CryptoType: TypeHash, Algorithm: "hash", Crypted: []byte("test")}, []byte("test"), &mockHashCrypto{}},
			false,
		},
		{
			"wrong",
			args{&CryptoValue{CryptoType: TypeHash, Algorithm: "hash", Crypted: []byte("test")}, []byte("test"), &mockHashCrypto{}},
			false,
		},
		{
			"nil",
			args{nil, []byte("test2"), &mockHashCrypto{}},
			true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := CompareHash(tt.args.value, tt.args.comparer, tt.args.c); (err != nil) != tt.wantErr {
				t.Errorf("CompareHash() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}