jx/internal/resource/package_test.go

// Copyright 2024 Matthew Rich <matthewrich.conf@gmail.com>. All rights reserved

package resource

import (
	"context"
_	"encoding/json"
	"fmt"
	"github.com/stretchr/testify/assert"
_ "gopkg.in/yaml.v3"
_ "io"
	"log/slog"
_ "net/http"
_ "net/http/httptest"
_ "net/url"
_ "os"
_ "strings"
	"testing"
	"decl/internal/command"
)

func TestNewPackageResource(t *testing.T) {
	p := NewPackage()
	assert.NotNil(t, p)
}

func TestPackageApplyResourceTransformation(t *testing.T) {
	p := NewPackage()
	assert.NotNil(t, p)

	//e := f.Apply()
	//assert.Equal(t, nil, e)
}

func TestReadPackage(t *testing.T) {
	decl := `
name: vim
version: latest
type: apk
`

	p := NewPackage()
	assert.NotNil(t, p)
	m := &MockCommand{
		CommandExists: func() error { return nil },
		Executor: func(value any) ([]byte, error) {
			return nil, nil
		},
		Extractor: func(output []byte, target any) error {
			p.Name = "vim"
			p.Version = "1.1.1"
			p.State = "present"
			return nil
		},
	}

	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)
	assert.Equal(t, "latest", p.Version)

	p.ReadCommand = (*command.Command)(m)
	yaml, readErr := p.Read(context.Background())
	assert.Nil(t, readErr)
	assert.Greater(t, len(yaml), 0)
	slog.Info("read()", "yaml", yaml)
	assert.Equal(t, "1.1.1", p.Version)
	slog.Info("resource: ", "package", p) 
	assert.Nil(t, p.Validate())
}

func TestReadAptPackage(t *testing.T) {
	if ! PackageTypeApt.Exists() {
		t.Skip("Unsupported package type")
	}
	decl := `
name: vim
required: ">1.1.1"
type: apt
`
	p := NewPackage()
	assert.NotNil(t, p)
	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)
	assert.Equal(t, ">1.1.1", p.Required)
	p.ReadCommand = NewAptReadCommand()
	p.ReadCommand.Executor = func(value any) ([]byte, error) {
		return []byte(`
Package: vim
Version: 1.2.2
`), nil
	}
	yaml, readErr := p.Read(context.Background())
	assert.Nil(t, readErr)
	assert.Greater(t, len(yaml), 0)
	slog.Info("read()", "yaml", yaml)
	assert.Equal(t, "1.2.2", p.Version)
	assert.Nil(t, p.Validate())
}

func TestReadPackageError(t *testing.T) {
	ctx := context.Background()
	expected := fmt.Sprintf(`
name: missing
state: absent
type: %s 
`, SystemPackageType)

	decl := fmt.Sprintf(`
name: missing
type: %s
`, SystemPackageType)

	p := NewPackage()
	assert.NotNil(t, p)
	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)
	p.ReadCommand = SystemPackageType.NewReadCommand()
/*
	p.ReadCommand.Executor = func(value any) ([]byte, error) {
		return []byte(``), fmt.Errorf("exit status 1 dpkg-query: package 'makef' is not installed and no information is available\nUse dpkg --info (= dpkg-deb --info) to examine archive files.\n")
	}
*/
	p.ResolveId(ctx)
	yaml, readErr := p.Read(ctx)
	assert.ErrorIs(t, readErr, ErrResourceStateAbsent)
	assert.YAMLEq(t, expected, string(yaml))
	slog.Info("read()", "yaml", yaml)
	assert.Equal(t, "", p.Version)
	assert.Nil(t, p.Validate())
}

func TestCreatePackage(t *testing.T) {
}

func TestPackageSetURI(t *testing.T) {
	p := NewPackage()
	assert.NotNil(t, p)
	e := p.SetURI("package://" + "12345_key?type=apk")
	assert.Nil(t, e)
	assert.Equal(t, "package", p.Type())
	assert.Equal(t, "12345_key", p.Name)
}

func TestReadDebPackage(t *testing.T) {
	if ! PackageTypeDeb.Exists() {
		t.Skip("Unsupported package type")
	}

	decl := `
name: vim
source: vim-8.2.3995-1ubuntu2.17.deb
type: deb
`
	p := NewPackage()
	assert.NotNil(t, p)
	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)
	p.ReadCommand = NewDebReadCommand()
	p.ReadCommand.Executor = func(value any) ([]byte, error) {
		return []byte(`
Package: vim
Version: 1.2.2
`), nil
	}
	yaml, readErr := p.Read(context.Background())
	assert.Nil(t, readErr)

	slog.Info("Package.Read()", "package", p)
	assert.Greater(t, len(yaml), 0)
	slog.Info("read()", "yaml", yaml)
	assert.Equal(t, "1.2.2", p.Version)
	assert.Nil(t, p.Validate())
}

func TestPackageTypeErr(t *testing.T) {
	
	decl := `
name: vim
source: vim-8.2.3995-1ubuntu2.17.deb
type: deb
`
	p := NewPackage()
	assert.NotNil(t, p)
	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)
	p.ReadCommand = NewDebReadCommand()
	p.ReadCommand.CommandExists = func() error { return command.ErrUnknownCommand }
	p.ReadCommand.Executor = func(value any) ([]byte, error) {
		return []byte(`
Package: vim
Version: 1.2.2
`), nil
	}
	_, readErr := p.Read(context.Background())
	assert.ErrorIs(t, readErr, ErrUnsupportedPackageType)

}

func TestPackageSourceRef(t *testing.T) {
	decl := `
name: vim
sourceref: https://localhost/vim-8.2.3995-1ubuntu2.17.deb
type: deb
`

	p := NewPackage()
	assert.NotNil(t, p)
	loadErr := p.LoadDecl(decl)
	assert.Nil(t, loadErr)

	p.ReadCommand = NewDebReadCommand()
	p.ReadCommand.CommandExists = func() error { return command.ErrUnknownCommand }
	p.ReadCommand.Executor = func(value any) ([]byte, error) {
		return []byte(`
Package: vim
Version: 1.2.2
`), nil
	}
	_, readErr := p.Read(context.Background())
	assert.ErrorIs(t, readErr, ErrUnsupportedPackageType)
}