Skip to content

Commit 7aba0e1

Browse files
martacarbonemartacarbone
committed
Define the port only as custom input.
1 parent 776bcca commit 7aba0e1

File tree

2 files changed

+63
-138
lines changed

2 files changed

+63
-138
lines changed

‎cmd/arduino-app-cli/version/version.go‎

Lines changed: 17 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -18,10 +18,10 @@ package version
1818
import (
1919
"encoding/json"
2020
"fmt"
21+
2122
"net"
2223
"net/http"
2324
"net/url"
24-
"strings"
2525
"time"
2626

2727
"github.com/spf13/cobra"
@@ -40,73 +40,39 @@ const (
4040
func NewVersionCmd(clientVersion string) *cobra.Command {
4141
cmd := &cobra.Command{
4242
Use: "version",
43-
Short: "Print the client and server versions for the Arduino App CLI.",
43+
Short: "Print the client and server versions for the Arduino App CLI",
4444
Run: func(cmd *cobra.Command, args []string) {
45-
host, _ := cmd.Flags().GetString("host")
45+
port, _ := cmd.Flags().GetString("port")
4646

47-
validatedHostAndPort, err := validateHost(host)
47+
daemonVersion, err := getDaemonVersion(http.Client{}, port)
4848
if err != nil {
49-
feedback.Fatal("Error: invalid host:port format", feedback.ErrBadArgument)
49+
feedback.Warnf("Warning: cannot get the running daemon version on %s:%s\n", DefaultHostname, port)
5050
}
5151

52-
httpClient := http.Client{
53-
Timeout: time.Second,
52+
result := versionResult{
53+
Name: ProgramName,
54+
Version: clientVersion,
55+
DaemonVersion: daemonVersion,
5456
}
5557

56-
result, err := versionHandler(httpClient, clientVersion, validatedHostAndPort)
57-
if err != nil {
58-
feedback.Warnf("Waning: " + err.Error() + "\n")
59-
}
6058
feedback.PrintResult(result)
6159
},
6260
}
63-
cmd.Flags().String("host", fmt.Sprintf("%s:%s", DefaultHostname, DefaultPort),
64-
"The daemon network address [host]:[port]")
61+
cmd.Flags().String("port", DefaultPort, "The daemon network port")
6562
return cmd
6663
}
6764

68-
func versionHandler(httpClient http.Client, clientVersion string, hostAndPort string) (versionResult, error) {
65+
func getDaemonVersion(httpClient http.Client, port string) (string, error) {
66+
67+
httpClient.Timeout = time.Second
68+
6969
url := url.URL{
7070
Scheme: "http",
71-
Host: hostAndPort,
71+
Host: net.JoinHostPort(DefaultHostname, port),
7272
Path: "/v1/version",
7373
}
7474

75-
daemonVersion, err := getDaemonVersion(httpClient, url.String())
76-
77-
result := versionResult{
78-
Name: ProgramName,
79-
Version: clientVersion,
80-
DaemonVersion: daemonVersion,
81-
}
82-
83-
if err != nil {
84-
return result, fmt.Errorf("error getting daemon version %s", hostAndPort)
85-
}
86-
return result, nil
87-
}
88-
89-
func validateHost(hostPort string) (string, error) {
90-
if !strings.Contains(hostPort, ":") {
91-
hostPort += ":"
92-
}
93-
94-
h, p, err := net.SplitHostPort(hostPort)
95-
if err != nil {
96-
return "", err
97-
}
98-
if h == "" {
99-
h = DefaultHostname
100-
}
101-
if p == "" {
102-
p = DefaultPort
103-
}
104-
105-
return net.JoinHostPort(h, p), nil
106-
}
107-
108-
func getDaemonVersion(httpClient http.Client, url string) (string, error) {
109-
resp, err := httpClient.Get(url)
75+
resp, err := httpClient.Get(url.String())
11076
if err != nil {
11177
return "", err
11278
}
@@ -133,7 +99,7 @@ type versionResult struct {
13399
}
134100

135101
func (r versionResult) String() string {
136-
resultMessage := fmt.Sprintf("%s client version %s",
102+
resultMessage := fmt.Sprintf("%s version %s",
137103
ProgramName, r.Version)
138104

139105
if r.DaemonVersion != "" {

‎cmd/arduino-app-cli/version/version_test.go‎

Lines changed: 46 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -25,115 +25,66 @@ import (
2525
"github.com/stretchr/testify/require"
2626
)
2727

28-
func TestGetValidUrl(t *testing.T) {
28+
func TestDaemonVersion(t *testing.T) {
2929
testCases := []struct {
30-
name string
31-
hostPort string
32-
expectedResult string
30+
name string
31+
serverStub Tripper
32+
port string
33+
expectedResult string
34+
expectedErrorMessage string
3335
}{
3436
{
35-
name: "Valid host and port should return default.",
36-
hostPort: "localhost:8800",
37-
expectedResult: "localhost:8800",
37+
name: "return the server version when the server is up",
38+
serverStub: successServer,
39+
port: "8800",
40+
expectedResult: "3.0-server",
41+
expectedErrorMessage: "",
3842
},
3943
{
40-
name: "Missing host should return default host.",
41-
hostPort: ":8800",
42-
expectedResult: "localhost:8800",
44+
name: "return error if default server is not listening on default port",
45+
serverStub: failureServer,
46+
port: "8800",
47+
expectedResult: "",
48+
expectedErrorMessage: `Get "http://localhost:8800/v1/version": connection refused`,
4349
},
4450
{
45-
name: "Missing port should return default port.",
46-
hostPort: "localhost:",
47-
expectedResult: "localhost:8800",
51+
name: "return error if provided server is not listening on provided port",
52+
serverStub: failureServer,
53+
port: "1234",
54+
expectedResult: "",
55+
expectedErrorMessage: `Get "http://localhost:1234/v1/version": connection refused`,
4856
},
4957
{
50-
name: "Custom host and port should return the provided host:port.",
51-
hostPort: "192.168.100.1:1234",
52-
expectedResult: "192.168.100.1:1234",
58+
name: "return error for server response 500 Internal Server Error",
59+
serverStub: failureInternalServerError,
60+
port: "0",
61+
expectedResult: "",
62+
expectedErrorMessage: "unexpected status code received",
5363
},
54-
{
55-
name: "Host only should return provided input and default port.",
56-
hostPort: "192.168.1.1",
57-
expectedResult: "192.168.1.1:8800",
58-
},
59-
{
60-
name: "Missing host and port should return default.",
61-
hostPort: "",
62-
expectedResult: "localhost:8800",
63-
},
64-
}
65-
66-
for _, tc := range testCases {
67-
t.Run(tc.name, func(t *testing.T) {
68-
url, _ := validateHost(tc.hostPort)
69-
require.Equal(t, tc.expectedResult, url)
70-
})
71-
}
72-
}
7364

74-
func TestServerVersion(t *testing.T) {
75-
clientVersion := "5.1-dev"
76-
unreacheableUrl := "unreacheable:123"
77-
daemonVersion := ""
78-
79-
testCases := []struct {
80-
name string
81-
serverStub Tripper
82-
expectedResult versionResult
83-
hostAndPort string
84-
}{
8565
{
86-
name: "return the server version when the server is up",
87-
serverStub: successServer,
88-
expectedResult: versionResult{
89-
Name: ProgramName,
90-
Version: clientVersion,
91-
DaemonVersion: "3.0",
92-
},
93-
hostAndPort: "localhost:8800",
94-
},
95-
{
96-
name: "return error if default server is not listening",
97-
serverStub: failureServer,
98-
expectedResult: versionResult{
99-
Name: ProgramName,
100-
Version: clientVersion,
101-
DaemonVersion: daemonVersion,
102-
},
103-
hostAndPort: unreacheableUrl,
104-
},
105-
{
106-
name: "return error if provided server is not listening",
107-
serverStub: failureServer,
108-
expectedResult: versionResult{
109-
Name: ProgramName,
110-
Version: clientVersion,
111-
DaemonVersion: daemonVersion,
112-
},
113-
hostAndPort: unreacheableUrl,
114-
},
115-
{
116-
name: "return error for server resopnse 500 Internal Server Error",
117-
serverStub: failureInternalServerError,
118-
expectedResult: versionResult{
119-
Name: ProgramName,
120-
Version: clientVersion,
121-
DaemonVersion: daemonVersion,
122-
},
123-
hostAndPort: unreacheableUrl,
66+
name: "return error for server up and wrong json response",
67+
serverStub: successServerWrongJson,
68+
port: "8800",
69+
expectedResult: "",
70+
expectedErrorMessage: "invalid character '<' looking for beginning of value",
12471
},
12572
}
73+
12674
for _, tc := range testCases {
12775
t.Run(tc.name, func(t *testing.T) {
12876
// arrange
12977
httpClient := http.Client{}
13078
httpClient.Transport = tc.serverStub
13179

13280
// act
133-
result, _ := versionHandler(httpClient, clientVersion, tc.hostAndPort)
81+
result, err := getDaemonVersion(httpClient, tc.port)
13482

13583
// assert
13684
require.Equal(t, tc.expectedResult, result)
85+
if err != nil {
86+
require.Equal(t, tc.expectedErrorMessage, err.Error())
87+
}
13788
})
13889
}
13990
}
@@ -147,15 +98,23 @@ func (t Tripper) RoundTrip(request *http.Request) (*http.Response, error) {
14798
}
14899

149100
var successServer = Tripper(func(*http.Request) (*http.Response, error) {
150-
body := io.NopCloser(strings.NewReader(`{"version":"3.0"}`))
101+
body := io.NopCloser(strings.NewReader(`{"version":"3.0-server"}`))
102+
return &http.Response{
103+
StatusCode: http.StatusOK,
104+
Body: body,
105+
}, nil
106+
})
107+
108+
var successServerWrongJson = Tripper(func(*http.Request) (*http.Response, error) {
109+
body := io.NopCloser(strings.NewReader(`<!doctype html><html lang="en"`))
151110
return &http.Response{
152111
StatusCode: http.StatusOK,
153112
Body: body,
154113
}, nil
155114
})
156115

157116
var failureServer = Tripper(func(*http.Request) (*http.Response, error) {
158-
return nil, errors.New("connetion refused")
117+
return nil, errors.New("connection refused")
159118
})
160119

161120
var failureInternalServerError = Tripper(func(*http.Request) (*http.Response, error) {

0 commit comments

Comments
 (0)