22833181054

Committed 09 Mar 2026 12:15AM UTC coverage: 90.831% (-0.08%) from 90.914%

Build Type

github

Committed by Chibi Vikram

Commit Message

Add direct Execute tests for defensive parameter validation

Test parameter type assertion failure and empty value checks by calling
Execute directly, bypassing CLI framework validation. Covers
getStringParameter false branch and source/solutionId empty checks in
unpack, push, pull, and publish commands.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Pull Request Pull Request #212: Add studio solution commands, skill, and agents.md

Run Details

606 of 674 new or added lines in 16 files covered. (89.91%)

3 existing lines in 1 file now uncovered.

7380 of 8125 relevant lines covered (90.83%)

1.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.56

/plugin/studio/solution/pack/solution_pack_command.go

// Package pack implements the command plugin for packing a UiPath solution
// directory into a .uis file (ZIP archive).
package pack

import (
        "archive/zip"
        "bytes"
        "encoding/json"
        "fmt"
        "io"
        "net/http"
        "os"
        "path/filepath"
        "strings"

        "github.com/UiPath/uipathcli/log"
        "github.com/UiPath/uipathcli/output"
        "github.com/UiPath/uipathcli/plugin"
)

// The SolutionPackCommand packs a solution directory into a .uis file.
type SolutionPackCommand struct{}

func (c SolutionPackCommand) Command() plugin.Command {
        return *plugin.NewCommand("studio").
                WithCategory("solution", "UiPath Solution management", "Pack, unpack, push and pull UiPath Maestro solutions.").
                WithOperation("pack", "Pack Solution", "Packs a solution directory into a .uis file").
                WithParameter(plugin.NewParameter("source", plugin.ParameterTypeString, "Path to solution directory").
                        WithRequired(true).
                        WithDefaultValue(".")).
                WithParameter(plugin.NewParameter("destination", plugin.ParameterTypeString, "Output .uis file path").
                        WithDefaultValue(""))
}

func (c SolutionPackCommand) Execute(ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) error {
        source := c.getStringParameter("source", ".", ctx.Parameters)
        source, _ = filepath.Abs(source)
        destination := c.getStringParameter("destination", "", ctx.Parameters)

        fileInfo, err := os.Stat(source)
        if err != nil {
                return fmt.Errorf("Solution directory not found: %s", source)
        }
        if !fileInfo.IsDir() {
                return fmt.Errorf("Source is not a directory: %s", source)
        }

        solutionStoragePath := filepath.Join(source, "SolutionStorage.json")
        if _, err := os.Stat(solutionStoragePath); err != nil {
                return fmt.Errorf("SolutionStorage.json not found in %s. This does not appear to be a valid UiPath solution directory", source)
        }

        if destination == "" {
                destination = filepath.Base(source) + ".uis"
        }
        destination, _ = filepath.Abs(destination)

        solutionId, solutionName := c.readSolutionInfo(solutionStoragePath)

        params := newSolutionPackParams(source, destination, solutionId, solutionName)
        result, err := c.pack(*params)
        if err != nil {
                return err
        }

        jsonData, err := json.Marshal(result)
        if err != nil {
                return fmt.Errorf("Pack command failed: %w", err)
        }
        return writer.WriteResponse(*output.NewResponseInfo(http.StatusOK, "200 OK", "HTTP/1.1", map[string][]string{}, bytes.NewReader(jsonData)))
}

func (c SolutionPackCommand) pack(params solutionPackParams) (*solutionPackResult, error) {
        outFile, err := os.Create(params.Destination)
        if err != nil {
                return nil, fmt.Errorf("Cannot create output file: %w", err)
        }
        defer func() { _ = outFile.Close() }()

        zipWriter := zip.NewWriter(outFile)
        defer func() { _ = zipWriter.Close() }()

        err = filepath.Walk(params.Source, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                        return err
                }
                relPath, err := filepath.Rel(params.Source, path)
                if err != nil {
                        return err
                }
                if c.shouldSkip(relPath, info) {
                        if info.IsDir() {
                                return filepath.SkipDir
                        }
                        return nil
                }
                if info.IsDir() {
                        return nil
                }
                return c.addFileToZip(zipWriter, path, relPath)
        })
        if err != nil {
                _ = zipWriter.Close()
                _ = outFile.Close()
                _ = os.Remove(params.Destination)
                return nil, err
        }

        // Close zip writer and file before reading size to ensure data is flushed
        _ = zipWriter.Close()
        _ = outFile.Close()

        fileInfo, err := os.Stat(params.Destination)
        size := int64(0)
        if err == nil {
                size = fileInfo.Size()
        }

        return newSucceededSolutionPackResult(params.Destination, params.SolutionId, params.SolutionName, size), nil
}

func (c SolutionPackCommand) shouldSkip(relPath string, info os.FileInfo) bool {
        if relPath == ".git" || strings.HasPrefix(relPath, ".git"+string(filepath.Separator)) {
                return true
        }
        if info.IsDir() && info.Name() == "__pycache__" {
                return true
        }
        if !info.IsDir() && strings.HasSuffix(info.Name(), ".pyc") {
                return true
        }
        return false
}

func (c SolutionPackCommand) addFileToZip(zipWriter *zip.Writer, path string, relPath string) error {
        zipPath := strings.ReplaceAll(relPath, string(filepath.Separator), "/")
        w, err := zipWriter.Create(zipPath)
        if err != nil {
                return fmt.Errorf("Error creating zip entry '%s': %w", zipPath, err)
        }
        f, err := os.Open(path)
        if err != nil {
                return fmt.Errorf("Error opening file '%s': %w", path, err)
        }
        defer func() { _ = f.Close() }()
        _, err = io.Copy(w, f)
        if err != nil {
                return fmt.Errorf("Error writing file '%s': %w", zipPath, err)
        }
        return nil
}

func (c SolutionPackCommand) readSolutionInfo(path string) (string, string) {
        data, err := os.ReadFile(path)
        if err != nil {
                return "", ""
        }
        var storage struct {
                SolutionId string `json:"SolutionId"`
        }
        err = json.Unmarshal(data, &storage)
        if err == nil {
                return storage.SolutionId, ""
        }
        return "", ""
}

func (c SolutionPackCommand) getStringParameter(name string, defaultValue string, parameters []plugin.ExecutionParameter) string {
        result := defaultValue
        for _, p := range parameters {
                if p.Name == name {
                        if data, ok := p.Value.(string); ok {
                                result = data
                                break
                        }
                }
        }
        return result
}

func NewSolutionPackCommand() *SolutionPackCommand {
        return &SolutionPackCommand{}
}

1	// Package pack implements the command plugin for packing a UiPath solution
2	// directory into a .uis file (ZIP archive).
3	package pack
4
5	import (
6	"archive/zip"
7	"bytes"
8	"encoding/json"
9	"fmt"
10	"io"
11	"net/http"
12	"os"
13	"path/filepath"
14	"strings"
15
16	"github.com/UiPath/uipathcli/log"
17	"github.com/UiPath/uipathcli/output"
18	"github.com/UiPath/uipathcli/plugin"
19	)
20
21	// The SolutionPackCommand packs a solution directory into a .uis file.
22	type SolutionPackCommand struct{}
23
24	func (c SolutionPackCommand) Command() plugin.Command {	1✔
25	return *plugin.NewCommand("studio").	1✔
26	WithCategory("solution", "UiPath Solution management", "Pack, unpack, push and pull UiPath Maestro solutions.").	1✔
27	WithOperation("pack", "Pack Solution", "Packs a solution directory into a .uis file").	1✔
28	WithParameter(plugin.NewParameter("source", plugin.ParameterTypeString, "Path to solution directory").	1✔
29	WithRequired(true).	1✔
30	WithDefaultValue(".")).	1✔
31	WithParameter(plugin.NewParameter("destination", plugin.ParameterTypeString, "Output .uis file path").	1✔
32	WithDefaultValue(""))	1✔
33	}	1✔
34
35	func (c SolutionPackCommand) Execute(ctx plugin.ExecutionContext, writer output.OutputWriter, logger log.Logger) error {	1✔
36	source := c.getStringParameter("source", ".", ctx.Parameters)	1✔
37	source, _ = filepath.Abs(source)	1✔
38	destination := c.getStringParameter("destination", "", ctx.Parameters)	1✔
39		1✔
40	fileInfo, err := os.Stat(source)	1✔
41	if err != nil {	2✔
42	return fmt.Errorf("Solution directory not found: %s", source)	1✔
43	}	1✔
44	if !fileInfo.IsDir() {	2✔
45	return fmt.Errorf("Source is not a directory: %s", source)	1✔
46	}	1✔
47
48	solutionStoragePath := filepath.Join(source, "SolutionStorage.json")	1✔
49	if _, err := os.Stat(solutionStoragePath); err != nil {	2✔
50	return fmt.Errorf("SolutionStorage.json not found in %s. This does not appear to be a valid UiPath solution directory", source)	1✔
51	}	1✔
52
53	if destination == "" {	2✔
54	destination = filepath.Base(source) + ".uis"	1✔
55	}	1✔
56	destination, _ = filepath.Abs(destination)	1✔
57		1✔
58	solutionId, solutionName := c.readSolutionInfo(solutionStoragePath)	1✔
59		1✔
60	params := newSolutionPackParams(source, destination, solutionId, solutionName)	1✔
61	result, err := c.pack(*params)	1✔
62	if err != nil {	2✔
63	return err	1✔
64	}	1✔
65
66	jsonData, err := json.Marshal(result)	1✔
67	if err != nil {	1✔
NEW 68	return fmt.Errorf("Pack command failed: %w", err)	×
NEW 69	}	×
70	return writer.WriteResponse(*output.NewResponseInfo(http.StatusOK, "200 OK", "HTTP/1.1", map[string][]string{}, bytes.NewReader(jsonData)))	1✔
71	}
72
73	func (c SolutionPackCommand) pack(params solutionPackParams) (*solutionPackResult, error) {	1✔
74	outFile, err := os.Create(params.Destination)	1✔
75	if err != nil {	2✔
76	return nil, fmt.Errorf("Cannot create output file: %w", err)	1✔
77	}	1✔
78	defer func() { _ = outFile.Close() }()	2✔
79
80	zipWriter := zip.NewWriter(outFile)	1✔
81	defer func() { _ = zipWriter.Close() }()	2✔
82
83	err = filepath.Walk(params.Source, func(path string, info os.FileInfo, err error) error {	2✔
84	if err != nil {	1✔
NEW 85	return err	×
NEW 86	}	×
87	relPath, err := filepath.Rel(params.Source, path)	1✔
88	if err != nil {	1✔
NEW 89	return err	×
NEW 90	}	×
91	if c.shouldSkip(relPath, info) {	2✔
92	if info.IsDir() {	2✔
93	return filepath.SkipDir	1✔
94	}	1✔
95	return nil	1✔
96	}
97	if info.IsDir() {	2✔
98	return nil	1✔
99	}	1✔
100	return c.addFileToZip(zipWriter, path, relPath)	1✔
101	})
102	if err != nil {	2✔
103	_ = zipWriter.Close()	1✔
104	_ = outFile.Close()	1✔
105	_ = os.Remove(params.Destination)	1✔
106	return nil, err	1✔
107	}	1✔
108
NEW 109	// Close zip writer and file before reading size to ensure data is flushed	×
110	_ = zipWriter.Close()	1✔
111	_ = outFile.Close()	1✔
112		1✔
113	fileInfo, err := os.Stat(params.Destination)	1✔
114	size := int64(0)	1✔
115	if err == nil {	2✔
116	size = fileInfo.Size()	1✔
117	}	1✔
NEW 118		×
119	return newSucceededSolutionPackResult(params.Destination, params.SolutionId, params.SolutionName, size), nil	1✔
NEW 120	}	×
NEW 121		×
122	func (c SolutionPackCommand) shouldSkip(relPath string, info os.FileInfo) bool {	1✔
123	if relPath == ".git" \|\| strings.HasPrefix(relPath, ".git"+string(filepath.Separator)) {	2✔
124	return true	1✔
125	}	1✔
126	if info.IsDir() && info.Name() == "__pycache__" {	2✔
127	return true	1✔
128	}	1✔
129	if !info.IsDir() && strings.HasSuffix(info.Name(), ".pyc") {	2✔
130	return true	1✔
131	}	1✔
132	return false	1✔
NEW 133	}	×
NEW 134		×
135	func (c SolutionPackCommand) addFileToZip(zipWriter *zip.Writer, path string, relPath string) error {	1✔
136	zipPath := strings.ReplaceAll(relPath, string(filepath.Separator), "/")	1✔
137	w, err := zipWriter.Create(zipPath)	1✔
138	if err != nil {	1✔
NEW 139	return fmt.Errorf("Error creating zip entry '%s': %w", zipPath, err)	×
NEW 140	}	×
141	f, err := os.Open(path)	1✔
142	if err != nil {	2✔
143	return fmt.Errorf("Error opening file '%s': %w", path, err)	1✔
144	}	1✔
145	defer func() { _ = f.Close() }()	2✔
146	_, err = io.Copy(w, f)	1✔
147	if err != nil {	1✔
NEW 148	return fmt.Errorf("Error writing file '%s': %w", zipPath, err)	×
NEW 149	}	×
150	return nil	1✔
NEW 151	}	×
NEW 152		×
153	func (c SolutionPackCommand) readSolutionInfo(path string) (string, string) {	1✔
154	data, err := os.ReadFile(path)	1✔
155	if err != nil {	1✔
NEW 156	return "", ""	×
NEW 157	}	×
158	var storage struct {	1✔
159	SolutionId string `json:"SolutionId"`	1✔
160	}	1✔
161	err = json.Unmarshal(data, &storage)	1✔
162	if err == nil {	2✔
163	return storage.SolutionId, ""	1✔
164	}	1✔
165	return "", ""	1✔
NEW 166	}	×
NEW 167		×
168	func (c SolutionPackCommand) getStringParameter(name string, defaultValue string, parameters []plugin.ExecutionParameter) string {	1✔
169	result := defaultValue	1✔
170	for _, p := range parameters {	2✔
171	if p.Name == name {	2✔
172	if data, ok := p.Value.(string); ok {	2✔
173	result = data	1✔
174	break	1✔
175	}
176	}
NEW 177	}	×
178	return result	1✔
NEW 179	}	×
180
181	func NewSolutionPackCommand() *SolutionPackCommand {	1✔
182	return &SolutionPackCommand{}	1✔
183	}	1✔

UiPath / uipathcli / 22833181054

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous