opensource/cocos
1
0
Fork 0
mirror of https://github.com/ultravioletrs/cocos.git synced 2026-06-23 04:10:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

NOISSUE - Add pkg tests (#269)

Browse Source 
* add pkg tests

Signed-off-by: Sammy Oina <sammyoina@gmail.com>

* rename function

Signed-off-by: Sammy Oina <sammyoina@gmail.com>

---------

Signed-off-by: Sammy Oina <sammyoina@gmail.com>
This commit is contained in:
Sammy Kerata Oina
2024-10-08 16:50:50 +03:00
committed by GitHub
parent 5e01ecdab7
commit 643c132ff7
4 changed files with 196 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cli/cache.go
+1 -1
View File
@@ -27,7 +27,7 @@ func (cli *CLI) NewCABundleCmd(fileSavePath string) *cobra.Command {
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
attestationConfiguration := grpc.AttestationConfiguration{}
err := grpc.ReadManifest(args[0], &attestationConfiguration)
err := grpc.ReadBackendInfo(args[0], &attestationConfiguration)
if err != nil {
log.Fatalf("Error while reading manifest: %v", err)
}
pkg/clients/grpc/connect.go
+3 -3
View File
@@ -68,7 +68,7 @@ type Config struct {
URL string `env:"URL" envDefault:"localhost:7001"`
Timeout time.Duration `env:"TIMEOUT" envDefault:"60s"`
AttestedTLS bool `env:"ATTESTED_TLS" envDefault:"false"`
Manifest string `env:"MANIFEST" envDefault:""`
BackendInfo string `env:"BACKEND_INFO" envDefault:""`
}
type AttestationConfiguration struct {
@@ -142,7 +142,7 @@ func connect(cfg Config) (*grpc.ClientConn, security, error) {
tc := insecure.NewCredentials()
if cfg.AttestedTLS {
err := ReadManifest(cfg.Manifest, &attestationConfiguration)
err := ReadBackendInfo(cfg.BackendInfo, &attestationConfiguration)
if err != nil {
return nil, secure, fmt.Errorf("failed to read Manifest %w", err)
}
@@ -193,7 +193,7 @@ func connect(cfg Config) (*grpc.ClientConn, security, error) {
return conn, secure, nil
}
func ReadManifest(manifestPath string, attestationConfiguration *AttestationConfiguration) error {
func ReadBackendInfo(manifestPath string, attestationConfiguration *AttestationConfiguration) error {
if manifestPath != "" {
manifest, err := os.Open(manifestPath)
if err != nil {
pkg/clients/grpc/connect_test.go
+192
View File
@@ -0,0 +1,192 @@
// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0
package grpc
import (
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"math/big"
"os"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNewClient(t *testing.T) {
caCertFile, clientCertFile, clientKeyFile, err := createCertificatesFiles()
require.NoError(t, err)
t.Cleanup(func() {
os.Remove(caCertFile)
os.Remove(clientCertFile)
os.Remove(clientKeyFile)
})
tests := []struct {
name string
cfg Config
wantErr bool
}{
{
name: "Success without TLS",
cfg: Config{
URL: "localhost:7001",
},
wantErr: false,
},
{
name: "Success with TLS",
cfg: Config{
URL: "localhost:7001",
ServerCAFile: caCertFile,
},
wantErr: false,
},
{
name: "Success with mTLS",
cfg: Config{
URL: "localhost:7001",
ServerCAFile: caCertFile,
ClientCert: clientCertFile,
ClientKey: clientKeyFile,
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
client, err := NewClient(tt.cfg)
if tt.wantErr {
assert.Error(t, err)
assert.Nil(t, client)
} else {
assert.NoError(t, err)
assert.NotNil(t, client)
assert.NoError(t, client.Close())
}
})
}
}
func TestClientSecure(t *testing.T) {
tests := []struct {
name string
secure security
expected string
}{
{
name: "Without TLS",
secure: withoutTLS,
expected: "without TLS",
},
{
name: "With TLS",
secure: withTLS,
expected: "with TLS",
},
{
name: "With mTLS",
secure: withmTLS,
expected: "with mTLS",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := &client{secure: tt.secure}
assert.Equal(t, tt.expected, c.Secure())
})
}
}
func createCertificatesFiles() (string, string, string, error) {
caKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return "", "", "", err
}
caTemplate := x509.Certificate{
SerialNumber: big.NewInt(1),
Subject: pkix.Name{
Organization: []string{"Test Org"},
},
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour * 24),
KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
BasicConstraintsValid: true,
IsCA: true,
}
caCertDER, err := x509.CreateCertificate(rand.Reader, &caTemplate, &caTemplate, &caKey.PublicKey, caKey)
if err != nil {
return "", "", "", err
}
caCertFile, err := createTempFile(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: caCertDER}))
if err != nil {
return "", "", "", err
}
clientKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return "", "", "", err
}
clientTemplate := x509.Certificate{
SerialNumber: big.NewInt(2),
Subject: pkix.Name{
Organization: []string{"Test Org"},
},
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour * 24),
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
BasicConstraintsValid: true,
}
clientCertDER, err := x509.CreateCertificate(rand.Reader, &clientTemplate, &caTemplate, &clientKey.PublicKey, caKey)
if err != nil {
return "", "", "", err
}
clientCertFile, err := createTempFile(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: clientCertDER}))
if err != nil {
return "", "", "", err
}
clientKeyFile, err := createTempFile(pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(clientKey)}))
if err != nil {
return "", "", "", err
}
return caCertFile, clientCertFile, clientKeyFile, nil
}
func createTempFile(data []byte) (string, error) {
file, err := createTempFileHandle()
if err != nil {
return "", err
}
_, err = file.Write(data)
if err != nil {
return "", err
}
err = file.Close()
if err != nil {
return "", err
}
return file.Name(), nil
}
func createTempFileHandle() (*os.File, error) {
return os.CreateTemp("", "test")
}
pkg/socket/socket.go
-56
View File
@@ -1,56 +0,0 @@
// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0
package socket
import (
"fmt"
"io"
"net"
"os"
)
func StartUnixSocketServer(socketPath string) (net.Listener, error) {
// Remove any existing socket file
_ = os.Remove(socketPath)
// Create a Unix domain socket listener
listener, err := net.Listen("unix", socketPath)
if err != nil {
return nil, fmt.Errorf("error creating socket listener: %v", err)
}
fmt.Println("Unix domain socket server is listening on", socketPath)
return listener, nil
}
func AcceptConnection(listener net.Listener, dataChannel chan []byte, errorChannel chan error) {
conn, err := listener.Accept()
if err != nil {
errorChannel <- fmt.Errorf("error accepting connection:: %v", err)
}
handleConnection(conn, dataChannel, errorChannel)
}
func handleConnection(conn net.Conn, dataChannel chan []byte, errorChannel chan error) {
defer conn.Close()
// Create a dynamic buffer to store incoming data
var buffer []byte
tmp := make([]byte, 1024)
for {
// Read data into the temporary buffer
n, err := conn.Read(tmp)
if err != nil {
if err == io.EOF {
break
}
errorChannel <- err
}
buffer = append(buffer, tmp[:n]...)
}
dataChannel <- buffer
}