podman-remote.conf enablement

add the ability for the podman remote client to use a configuration file
which describes its connections. users can now define a connection the
configuration and then call it by name like:

podman-remote -c connection1

and the destination and user will be derived from the configuration
file.  if no -c is provided, we look for a connection in the
configuration file designated as 'default'.  If the configuration file
has only one connection, it will be deemed the 'default'.

Signed-off-by: baude <bbaude@redhat.com>

1 files changed, 201 insertions, 0 deletions

diff --git a/cmd/podman/remoteclientconfig/configfile_test.go b/cmd/podman/remoteclientconfig/configfile_test.go
new file mode 100644
index 000000000..66e0a4693
--- /dev/null
+++ b/cmd/podman/remoteclientconfig/configfile_test.go
@@ -0,0 +1,201 @@
+package remoteclientconfig
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var goodConfig = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+username = "myuser"
+default = true
+
+[connections.bart]
+destination = "foobar.com"
+username = "root"
+`
+var noDest = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+username = "myuser"
+default = true
+
+[connections.bart]
+username = "root"
+`
+
+var noUser = `
+[connections]
+
+[connections.homer]
+destination = "192.168.1.1"
+`
+
+func makeGoodResult() *RemoteConfig {
+	var goodConnections = make(map[string]RemoteConnection)
+	goodConnections["homer"] = RemoteConnection{
+		Destination: "192.168.1.1",
+		Username:    "myuser",
+		IsDefault:   true,
+	}
+	goodConnections["bart"] = RemoteConnection{
+		Destination: "foobar.com",
+		Username:    "root",
+	}
+	var goodResult = RemoteConfig{
+		Connections: goodConnections,
+	}
+	return &goodResult
+}
+
+func makeNoUserResult() *RemoteConfig {
+	var goodConnections = make(map[string]RemoteConnection)
+	goodConnections["homer"] = RemoteConnection{
+		Destination: "192.168.1.1",
+	}
+	var goodResult = RemoteConfig{
+		Connections: goodConnections,
+	}
+	return &goodResult
+}
+
+func TestReadRemoteConfig(t *testing.T) {
+	type args struct {
+		reader io.Reader
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *RemoteConfig
+		wantErr bool
+	}{
+		// good test should pass
+		{"good", args{reader: strings.NewReader(goodConfig)}, makeGoodResult(), false},
+		// a connection with no destination is an error
+		{"nodest", args{reader: strings.NewReader(noDest)}, nil, true},
+		// a connnection with no user is OK
+		{"nouser", args{reader: strings.NewReader(noUser)}, makeNoUserResult(), false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ReadRemoteConfig(tt.args.reader)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ReadRemoteConfig() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ReadRemoteConfig() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRemoteConfig_GetDefault(t *testing.T) {
+	good := make(map[string]RemoteConnection)
+	good["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+		IsDefault:   true,
+	}
+	good["bart"] = RemoteConnection{
+		Username:    "root",
+		Destination: "foobar.com",
+	}
+	noDefault := make(map[string]RemoteConnection)
+	noDefault["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+	}
+	noDefault["bart"] = RemoteConnection{
+		Username:    "root",
+		Destination: "foobar.com",
+	}
+	single := make(map[string]RemoteConnection)
+	single["homer"] = RemoteConnection{
+		Username:    "myuser",
+		Destination: "192.168.1.1",
+	}
+
+	none := make(map[string]RemoteConnection)
+
+	type fields struct {
+		Connections map[string]RemoteConnection
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		want    *RemoteConnection
+		wantErr bool
+	}{
+		// A good toml should return the connection that is marked isDefault
+		{"good", fields{Connections: makeGoodResult().Connections}, &RemoteConnection{"192.168.1.1", "myuser", true}, false},
+		// If nothing is marked as isDefault and there is more than one connection, error should occur
+		{"nodefault", fields{Connections: noDefault}, nil, true},
+		// if nothing is marked as isDefault but there is only one connection, the one connection is considered the default
+		{"single", fields{Connections: none}, nil, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &RemoteConfig{
+				Connections: tt.fields.Connections,
+			}
+			got, err := r.GetDefault()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("RemoteConfig.GetDefault() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("RemoteConfig.GetDefault() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRemoteConfig_GetRemoteConnection(t *testing.T) {
+	type fields struct {
+		Connections map[string]RemoteConnection
+	}
+	type args struct {
+		name string
+	}
+
+	blank := make(map[string]RemoteConnection)
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    *RemoteConnection
+		wantErr bool
+	}{
+		// Good connection
+		{"goodhomer", fields{Connections: makeGoodResult().Connections}, args{name: "homer"}, &RemoteConnection{"192.168.1.1", "myuser", true}, false},
+		// Good connection
+		{"goodbart", fields{Connections: makeGoodResult().Connections}, args{name: "bart"}, &RemoteConnection{"foobar.com", "root", false}, false},
+		// Getting an unknown connection should result in error
+		{"noexist", fields{Connections: makeGoodResult().Connections}, args{name: "foobar"}, nil, true},
+		// Getting a connection when there are none should result in an error
+		{"none", fields{Connections: blank}, args{name: "foobar"}, nil, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &RemoteConfig{
+				Connections: tt.fields.Connections,
+			}
+			got, err := r.GetRemoteConnection(tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("RemoteConfig.GetRemoteConnection() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("RemoteConfig.GetRemoteConnection() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}