certmanager/internal/test/logic_test.go

package test

import (
	"context"
	"fmt"
	"testing"
	"time"
	"strings"

	cmapi "certmanager/api/certmanagercontrol"
	"certmanager/internal/config"
	"certmanager/internal/database"
	"certmanager/internal/logic"

	"github.com/stretchr/testify/require"
        "sigs.k8s.io/yaml"
)

func TestLogicIssuer(t *testing.T) {
	var err error
	var lg *logic.Logic
	{
		conf := config.NewConfig()
		err = conf.ReadFile()
		require.NoError(t, err)

		db, err := database.NewDatabase(conf.DataDir)
		require.NoError(t, err)
		require.NotNil(t, db)

		err = db.InitDatabase()
		require.NoError(t, err)

		logicConfig := &logic.LogicConfig{
			Auths:    conf.Auths,
			Database: db,
		}
		lg, err = logic.NewLogic(logicConfig)
		require.NoError(t, err)
		require.NotNil(t, lg)
	}

	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)

	issuerCommonName := "foo.bar"
	var issuerID int64
	{
		createIssuerPairParams := &cmapi.CreateIssuerPairParams{
			IssuerCommonName: issuerCommonName,
		}
		createIssuerPairRes, err := lg.CreateIssuerPair(ctx, createIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, createIssuerPairRes)
		issuerID = createIssuerPairRes.IssuerID
		printObj("issuerID", issuerID)

	}
	var issuerCert string
	{
		getIssuerCertificateParams := &cmapi.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
		require.NoError(t, err)

		issuerCert = getIssuerCertificateRes.Certificate
		require.NotZero(t, len(issuerCert))
		printObj("issuerCert", string(issuerCert))
	}
	{
		revokeIssuerPairParams := &cmapi.RevokeIssuerPairParams{
			IssuerID: issuerID,
		}
		revokeIssuerPairRes, err := lg.RevokeIssuerPair(ctx, revokeIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, revokeIssuerPairRes)

		printObj("revokeIssuerPairRes", revokeIssuerPairRes)
		require.NoError(t, err)
	}
	{
		getIssuerCertificateParams := &cmapi.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))
		require.True(t, getIssuerCertificateRes.Revoked)

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
	}
	{
		unrevokeIssuerPairParams := &cmapi.UnrevokeIssuerPairParams{
			IssuerID: issuerID,
		}
		unrevokeIssuerPairRes, err := lg.UnrevokeIssuerPair(ctx, unrevokeIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, unrevokeIssuerPairRes)

		printObj("unrevokeIssuerPairRes", unrevokeIssuerPairRes)
		require.NoError(t, err)
	}
	{
		getIssuerCertificateParams := &cmapi.GetIssuerCertificateParams{
			IssuerID: issuerID,
		}
		getIssuerCertificateRes, err := lg.GetIssuerCertificate(ctx, getIssuerCertificateParams)
		require.NoError(t, err)
		require.NotNil(t, getIssuerCertificateRes)
		require.NotZero(t, len(getIssuerCertificateRes.Certificate))
		require.False(t, getIssuerCertificateRes.Revoked)

		printObj("getIssuerCertificateRes", getIssuerCertificateRes)
	}
	{
		listIssuerPairsParams := &cmapi.ListIssuerPairsParams{}
		listIssuerPairsRes, err := lg.ListIssuerPairs(ctx, listIssuerPairsParams)
		require.NoError(t, err)
		require.NotNil(t, listIssuerPairsRes)
		require.NotZero(t, len(listIssuerPairsRes.Issuers))

		printObj("listIssuerPairRes", listIssuerPairsRes)
	}
	{
		importIssuerPairParams := &cmapi.ImportIssuerPairParams{
			Certificate: issuerCert,
		}
		importIssuerPairRes, err := lg.ImportIssuerPair(ctx, importIssuerPairParams)
		require.NoError(t, err)
		require.NotNil(t, importIssuerPairRes)

		printObj("importIssuerPairRes", importIssuerPairRes)
	}
	{
                for i := 0; i < 3; i++ {
                        createIssuerPairParams := &cmapi.CreateIssuerPairParams{
                                IssuerCommonName: fmt.Sprintf("sub%0d.%s", i, issuerCommonName),
                        }
                        createIssuerPairRes, err := lg.CreateIssuerPair(ctx, createIssuerPairParams)
                        require.NoError(t, err)
                        require.NotNil(t, createIssuerPairRes)
                        issuerID = createIssuerPairRes.IssuerID
                        printObj("issuerID", issuerID)
                }
	}
	{
		listIssuerPairsParams := &cmapi.ListIssuerPairsParams{}
		listIssuerPairsRes, err := lg.ListIssuerPairs(ctx, listIssuerPairsParams)
		require.NoError(t, err)
		require.NotNil(t, listIssuerPairsRes)
		require.NotZero(t, len(listIssuerPairsRes.Issuers))

		printObj("listIssuerPairRes", listIssuerPairsRes)
	}
	serviceCommonName := "make.love"
	var serviceID int64
	{
		createServicePairParams := &cmapi.CreateServicePairParams{
			ServiceCommonName: serviceCommonName,
                        IssuerID: issuerID,
		}
		createServicePairRes, err := lg.CreateServicePair(ctx, createServicePairParams)
		printObj("createServicePairRes", createServicePairRes)

		require.NoError(t, err)
		require.NotNil(t, createServicePairRes)
		serviceID = createServicePairRes.ServiceID
		printObj("serviceID", serviceID)
	}
	{
		getServicePairParams := &cmapi.GetServicePairParams{
			ServiceID: serviceID,
		}
		getServicePairRes, err := lg.GetServicePair(ctx, getServicePairParams)
		require.NoError(t, err)
		require.NotNil(t, getServicePairRes)
		require.NotZero(t, len(getServicePairRes.Certificate))
		require.False(t, getServicePairRes.Revoked)

		printObj("getServicePairRes", getServicePairRes)
	}
}

func printObj(label string, obj any) {
	objBytes, _ := yaml.Marshal(obj)
	objString := string(objBytes)
	if strings.Count(objString, "\n") < 2 {
		fmt.Printf("==== %s: %s\n", label, objString)
	} else {
		fmt.Printf("==== %s ::\n%s\n", label, objString)
	}
}