test: add missing unit tests (#4885)

* chore: add missing unit tests

* add missing pkg tests

* missing pkgs

* remove data race for spinner

Author: Pantani

ignite/pkg/archive/tar_gz_test.go

@@ -0,0 +1,48 @@
+package archive
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCreateArchiveAndExtractArchive(t *testing.T) {
+	root := t.TempDir()
+	oldWD, err := os.Getwd()
+	require.NoError(t, err)
+	require.NoError(t, os.Chdir(root))
+	t.Cleanup(func() {
+		require.NoError(t, os.Chdir(oldWD))
+	})
+
+	src := "src"
+	require.NoError(t, os.MkdirAll(filepath.Join(src, "nested"), 0o755))
+	require.NoError(t, os.WriteFile(filepath.Join(src, "a.txt"), []byte("alpha"), 0o600))
+	require.NoError(t, os.WriteFile(filepath.Join(src, "nested", "b.txt"), []byte("beta"), 0o600))
+
+	var buf bytes.Buffer
+	require.NoError(t, CreateArchive(src, &buf))
+
+	dst := filepath.Join(root, "out")
+	require.NoError(t, os.MkdirAll(dst, 0o755))
+	require.NoError(t, ExtractArchive(dst, bytes.NewReader(buf.Bytes())))
+
+	gotA, err := os.ReadFile(filepath.Join(dst, "src", "a.txt"))
+	require.NoError(t, err)
+	require.Equal(t, "alpha", string(gotA))
+
+	gotB, err := os.ReadFile(filepath.Join(dst, "src", "nested", "b.txt"))
+	require.NoError(t, err)
+	require.Equal(t, "beta", string(gotB))
+}
+
+func TestAddToArchiveReturnsErrorForMissingFile(t *testing.T) {
+	var buf bytes.Buffer
+	require.NoError(t, CreateArchive(t.TempDir(), &buf))
+
+	err := addToArchive(nil, filepath.Join(t.TempDir(), "does-not-exist"))
+	require.Error(t, err)
+}

ignite/pkg/chaincmd/chaincmd_test.go

@@ -0,0 +1,166 @@
+package chaincmd
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ignite/cli/v29/ignite/pkg/cmdrunner/step"
+)
+
+func TestInitCommandBuildsExpectedCommand(t *testing.T) {
+	cmd := New("simd", WithChainID("my-chain"), WithHome("/tmp/simd"))
+
+	s := step.New(cmd.InitCommand("my-moniker"))
+
+	require.Equal(t, "simd", s.Exec.Command)
+	require.Equal(t, []string{
+		"init",
+		"my-moniker",
+		"--chain-id",
+		"my-chain",
+		"--home",
+		"/tmp/simd",
+	}, s.Exec.Args)
+}
+
+func TestAddKeyCommandAddsOptionalFieldsAndKeyringBackend(t *testing.T) {
+	cmd := New(
+		"simd",
+		WithKeyringBackend(KeyringBackendTest),
+		WithHome("/tmp/simd"),
+	)
+
+	s := step.New(cmd.AddKeyCommand("alice", "118", "3", "1"))
+
+	require.Equal(t, "simd", s.Exec.Command)
+	require.Equal(t, []string{
+		"keys",
+		"add",
+		"alice",
+		"--output",
+		"json",
+		"--coin-type",
+		"118",
+		"--account",
+		"3",
+		"--index",
+		"1",
+		"--keyring-backend",
+		"test",
+		"--home",
+		"/tmp/simd",
+	}, s.Exec.Args)
+}
+
+func TestAddKeyCommandSkipsEmptyOptionalFields(t *testing.T) {
+	cmd := New("simd")
+	s := step.New(cmd.AddKeyCommand("alice", "", "", ""))
+
+	require.Equal(t, "simd", s.Exec.Command)
+	require.Equal(t, []string{
+		"keys",
+		"add",
+		"alice",
+		"--output",
+		"json",
+	}, s.Exec.Args)
+}
+
+func TestStatusCommandAddsNodeFlag(t *testing.T) {
+	cmd := New(
+		"simd",
+		WithNodeAddress("http://127.0.0.1:26657"),
+		WithHome("/tmp/simd"),
+	)
+
+	s := step.New(cmd.StatusCommand())
+
+	require.Equal(t, "simd", s.Exec.Command)
+	require.Equal(t, []string{
+		"status",
+		"--node",
+		"http://127.0.0.1:26657",
+		"--home",
+		"/tmp/simd",
+	}, s.Exec.Args)
+}
+
+func TestCopyOverridesOptionsWithoutMutatingOriginal(t *testing.T) {
+	original := New("simd", WithChainID("chain-A"))
+	copied := original.Copy(WithChainID("chain-B"))
+
+	originalStep := step.New(original.InitCommand("alice"))
+	copiedStep := step.New(copied.InitCommand("alice"))
+
+	require.Equal(t, []string{
+		"init",
+		"alice",
+		"--chain-id",
+		"chain-A",
+	}, originalStep.Exec.Args)
+	require.Equal(t, []string{
+		"init",
+		"alice",
+		"--chain-id",
+		"chain-B",
+	}, copiedStep.Exec.Args)
+}
+
+func TestKeyringBackendFromString(t *testing.T) {
+	testCases := []struct {
+		name      string
+		input     string
+		expected  KeyringBackend
+		shouldErr bool
+	}{
+		{
+			name:     "unspecified",
+			input:    "",
+			expected: KeyringBackendUnspecified,
+		},
+		{
+			name:     "os",
+			input:    "os",
+			expected: KeyringBackendOS,
+		},
+		{
+			name:     "file",
+			input:    "file",
+			expected: KeyringBackendFile,
+		},
+		{
+			name:     "pass",
+			input:    "pass",
+			expected: KeyringBackendPass,
+		},
+		{
+			name:     "test",
+			input:    "test",
+			expected: KeyringBackendTest,
+		},
+		{
+			name:     "kwallet",
+			input:    "kwallet",
+			expected: KeyringBackendKwallet,
+		},
+		{
+			name:      "invalid",
+			input:     "invalid",
+			expected:  KeyringBackendUnspecified,
+			shouldErr: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := KeyringBackendFromString(tc.input)
+			require.Equal(t, tc.expected, got)
+			if tc.shouldErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}

ignite/pkg/chaincmd/runner/runner_test.go

@@ -0,0 +1,72 @@
+package chaincmdrunner
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewKV(t *testing.T) {
+	kv := NewKV("k", "v")
+	require.Equal(t, "k", kv.key)
+	require.Equal(t, "v", kv.value)
+}
+
+func TestFindMatchingCloseBracket(t *testing.T) {
+	data := []byte(`{"a":{"b":1}} trailing`)
+	idx := findMatchingCloseBracket(data, '{', '}')
+	require.Equal(t, 12, idx)
+
+	require.Equal(t, -1, findMatchingCloseBracket([]byte(`{"a":1`), '{', '}'))
+}
+
+func TestCleanAndValidateJSON(t *testing.T) {
+	raw := []byte("logs...\n{\"code\":0,\"raw_log\":\"ok\",\"txhash\":\"ABC\"}\nmore")
+	got, err := cleanAndValidateJSON(raw)
+	require.NoError(t, err)
+	require.Equal(t, `{"code":0,"raw_log":"ok","txhash":"ABC"}`, string(got))
+}
+
+func TestFallbackFormatDetectionConvertsYAML(t *testing.T) {
+	raw := []byte("code: 0\nraw_log: ok\ntxhash: ABC\n")
+	got, err := fallbackFormatDetection(raw)
+	require.NoError(t, err)
+	require.JSONEq(t, `{"code":0,"raw_log":"ok","txhash":"ABC"}`, string(got))
+}
+
+func TestJSONEnsuredBytes(t *testing.T) {
+	b := newBuffer()
+	_, err := b.WriteString("noise\n{\"k\":\"v\"}\n")
+	require.NoError(t, err)
+
+	got, err := b.JSONEnsuredBytes()
+	require.NoError(t, err)
+	require.JSONEq(t, `{"k":"v"}`, string(got))
+}
+
+func TestDecodeTxResult(t *testing.T) {
+	b := newBuffer()
+	_, err := b.WriteString("code: 0\nraw_log: ok\ntxhash: HASH\n")
+	require.NoError(t, err)
+
+	got, err := decodeTxResult(b)
+	require.NoError(t, err)
+	require.Equal(t, 0, got.Code)
+	require.Equal(t, "ok", got.RawLog)
+	require.Equal(t, "HASH", got.TxHash)
+}
+
+func TestQueryTxByEventsRequiresSelectors(t *testing.T) {
+	r := Runner{}
+	events, err := r.QueryTxByEvents(context.Background())
+	require.Error(t, err)
+	require.Nil(t, events)
+}
+
+func TestQueryTxByQueryRequiresSelectors(t *testing.T) {
+	r := Runner{}
+	events, err := r.QueryTxByQuery(context.Background())
+	require.Error(t, err)
+	require.Nil(t, events)
+}

ignite/pkg/chainregistry/chainregistry_test.go

@@ -0,0 +1,51 @@
+package chainregistry
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestChainSaveJSON(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "chain.json")
+	in := Chain{
+		ChainName: "ignite",
+		ChainID:   "ignite-1",
+	}
+
+	require.NoError(t, in.SaveJSON(path))
+
+	raw, err := os.ReadFile(path)
+	require.NoError(t, err)
+	var got Chain
+	require.NoError(t, json.Unmarshal(raw, &got))
+	require.Equal(t, in.ChainName, got.ChainName)
+	require.Equal(t, in.ChainID, got.ChainID)
+}
+
+func TestAssetListSaveJSON(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "assetlist.json")
+	in := AssetList{
+		ChainName: "ignite",
+		Assets: []Asset{
+			{
+				Name:   "Ignite",
+				Base:   "uignite",
+				Symbol: "IGNT",
+			},
+		},
+	}
+
+	require.NoError(t, in.SaveJSON(path))
+
+	raw, err := os.ReadFile(path)
+	require.NoError(t, err)
+	var got AssetList
+	require.NoError(t, json.Unmarshal(raw, &got))
+	require.Equal(t, in.ChainName, got.ChainName)
+	require.Len(t, got.Assets, 1)
+	require.Equal(t, "IGNT", got.Assets[0].Symbol)
+}

ignite/pkg/checksum/checksum_test.go

@@ -0,0 +1,48 @@
+package checksum
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestStrings(t *testing.T) {
+	h := sha256.Sum256([]byte("abc"))
+	require.Equal(t, fmt.Sprintf("%x", h[:]), Strings("a", "b", "c"))
+}
+
+func TestSum(t *testing.T) {
+	dir := t.TempDir()
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "a.txt"), []byte("alpha"), 0o600))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "b.txt"), []byte("beta"), 0o600))
+
+	out := filepath.Join(t.TempDir(), "checksums.txt")
+	require.NoError(t, Sum(dir, out))
+
+	content, err := os.ReadFile(out)
+	require.NoError(t, err)
+	text := string(content)
+	require.Contains(t, text, "  a.txt\n")
+	require.Contains(t, text, "  b.txt\n")
+}
+
+func TestBinary(t *testing.T) {
+	bin := filepath.Join(t.TempDir(), "fake-bin")
+	data := []byte("#!/bin/sh\necho test\n")
+	require.NoError(t, os.WriteFile(bin, data, 0o700))
+
+	want := sha256.Sum256(data)
+	got, err := Binary(bin)
+	require.NoError(t, err)
+	require.Equal(t, fmt.Sprintf("%x", want[:]), got)
+}
+
+func TestBinaryReturnsErrorForMissingFile(t *testing.T) {
+	_, err := Binary(strings.TrimSpace(filepath.Join(t.TempDir(), "missing-bin")))
+	require.Error(t, err)
+}