Adds ResourceGroupStreamManifestReader to ResourceGroupProvider

internal/live/rgprovider.go

@@ -4,6 +4,7 @@
 package live
 
 import (
+	"fmt"
 	"io"
 
 	"k8s.io/apimachinery/pkg/api/meta"
@@ -44,27 +45,41 @@ func (f *ResourceGroupProvider) ToRESTMapper() (meta.RESTMapper, error) {
 // ManifestReader returns the ResourceGroup inventory object version of
 // the ManifestReader.
 func (f *ResourceGroupProvider) ManifestReader(reader io.Reader, args []string) (manifestreader.ManifestReader, error) {
+	// Validate parameters.
+	if reader == nil && len(args) == 0 {
+		return nil, fmt.Errorf("unable to build ManifestReader without both reader or args")
+	}
+	if len(args) > 1 {
+		return nil, fmt.Errorf("expected one directory argument allowed; got (%s)", args)
+	}
+	// Create ReaderOptions for subsequent ManifestReader.
 	namespace, enforceNamespace, err := f.factory.ToRawKubeConfigLoader().Namespace()
 	if err != nil {
 		return nil, err
 	}
-
 	readerOptions := manifestreader.ReaderOptions{
 		Factory:          f.factory,
 		Namespace:        namespace,
 		EnforceNamespace: enforceNamespace,
 	}
-
-	// TODO(seans3): Add Kptfile/ResourceGroup version of StreamManifestReader,
-	// when there are no args.
-
-	pathReader := &manifestreader.PathManifestReader{
-		Path:          args[0],
-		ReaderOptions: readerOptions,
-	}
-
-	mReader := &ResourceGroupPathManifestReader{
-		pathReader: pathReader,
+	// No arguments means stream (using reader), while one argument
+	// means path manifest reader.
+	var rgReader manifestreader.ManifestReader
+	if len(args) == 0 {
+		rgReader = &ResourceGroupStreamManifestReader{
+			streamReader: &manifestreader.StreamManifestReader{
+				ReaderName:    "stdin",
+				Reader:        reader,
+				ReaderOptions: readerOptions,
+			},
+		}
+	} else {
+		rgReader = &ResourceGroupPathManifestReader{
+			pathReader: &manifestreader.PathManifestReader{
+				Path:          args[0],
+				ReaderOptions: readerOptions,
+			},
+		}
 	}
-	return mReader, nil
+	return rgReader, nil
 }

internal/live/rgprovider_test.go

@@ -0,0 +1,76 @@
+// Copyright 2020 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package live
+
+import (
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	cmdtesting "k8s.io/kubectl/pkg/cmd/testing"
+)
+
+func TestResourceGroupProvider_ManifestReader(t *testing.T) {
+	testCases := map[string]struct {
+		args     []string
+		reader   io.Reader
+		expected string
+		isError  bool
+	}{
+		"No args or reader is an error": {
+			args:     []string{},
+			reader:   nil,
+			expected: "",
+			isError:  true,
+		},
+		"More than one args is an error": {
+			args:     []string{"dir-1", "dir-2"},
+			reader:   nil,
+			expected: "",
+			isError:  true,
+		},
+		"No args returns stream reader": {
+			args:     []string{},
+			reader:   strings.NewReader("foo"),
+			expected: "*ResourceGroupStreamManifestReader",
+			isError:  false,
+		},
+		"One arg returns path reader": {
+			args:     []string{"/fake-directory-str"},
+			reader:   nil,
+			expected: "*ResourceGroupPathManifestReader",
+			isError:  false,
+		},
+	}
+
+	for tn, tc := range testCases {
+		t.Run(tn, func(t *testing.T) {
+			tf := cmdtesting.NewTestFactory().WithNamespace("test-ns")
+			defer tf.Cleanup()
+			rgProvider := NewResourceGroupProvider(tf)
+			actual, err := rgProvider.ManifestReader(tc.reader, tc.args)
+			// Check if there should be an error
+			if tc.isError {
+				if err == nil {
+					t.Fatalf("expected error but received none")
+				}
+				return
+			}
+			assert.NoError(t, err)
+			if tc.expected != getType(actual) {
+				t.Errorf("expected ManifestReader type (%s), got (%s)", tc.expected, getType(actual))
+			}
+		})
+	}
+}
+
+func getType(myvar interface{}) string {
+	t := reflect.TypeOf(myvar)
+	if t.Kind() == reflect.Ptr {
+		return "*" + t.Elem().Name()
+	}
+	return t.Name()
+}