feat: dav client added to new main

- dav/app used as proxy to be compatible with existing storager interface
- dav/main deleted
- config reader created for dav
- defer close added to main for config file

Author: serdarozerr

dav/app/app.go

@@ -1,72 +1,80 @@
 package app
 
 import (
-	"encoding/json"
 	"errors"
-	"flag"
 	"fmt"
-	"io"
-	"os"
+	"time"
 
 	davcmd "github.com/cloudfoundry/storage-cli/dav/cmd"
 	davconfig "github.com/cloudfoundry/storage-cli/dav/config"
 )
 
 type App struct {
 	runner davcmd.Runner
+	config davconfig.Config
 }
 
-func New(runner davcmd.Runner) (app App) {
-	app.runner = runner
-	return
+func New(r davcmd.Runner, c davconfig.Config) *App {
+	app := &App{runner: r, config: c}
+	return app
 }
 
-func (app App) Run(args []string) (err error) {
-	args = args[1:]
-	var configFilePath string
-	var printVersion bool
-
-	flagSet := flag.NewFlagSet("davcli-args", flag.ContinueOnError)
-	flagSet.StringVar(&configFilePath, "c", "", "Config file path")
-	flagSet.BoolVar(&printVersion, "v", false, "print version info")
+func (app *App) run(args []string) (err error) {
 
-	err = flagSet.Parse(args)
+	err = app.runner.SetConfig(app.config)
 	if err != nil {
+		err = fmt.Errorf("Invalid CA Certificate: %s", err.Error()) //nolint:staticcheck
 		return
 	}
 
-	if printVersion {
-		fmt.Println("davcli version [[version]]")
-		return
-	}
+	err = app.runner.Run(args)
+	return
+}
 
-	if configFilePath == "" {
-		err = errors.New("Config file arg `-c` is missing") //nolint:staticcheck
-		return
-	}
+func (app *App) Put(sourceFilePath string, destinationObject string) error {
+	return app.run([]string{"put", sourceFilePath, destinationObject})
+}
 
-	file, err := os.Open(configFilePath)
-	if err != nil {
-		return
-	}
+func (app *App) Get(sourceObject string, dest string) error {
+	return app.run([]string{"get", sourceObject, dest})
+}
 
-	configBytes, err := io.ReadAll(file)
-	if err != nil {
-		return
-	}
+func (app *App) Delete(object string) error {
+	return app.run([]string{"delete", object})
+}
 
-	config := davconfig.Config{}
-	err = json.Unmarshal(configBytes, &config)
+func (app *App) Exists(object string) (bool, error) {
+	err := app.run([]string{"exists", object})
 	if err != nil {
-		return
+		return false, err
 	}
+	return true, nil
+}
 
-	err = app.runner.SetConfig(config)
+func (app *App) Sign(object string, action string, expiration time.Duration) (string, error) {
+	err := app.run([]string{"sign", object, action, expiration.String()})
 	if err != nil {
-		err = fmt.Errorf("Invalid CA Certificate: %s", err.Error()) //nolint:staticcheck
-		return
+		return "", err
 	}
+	return "", nil
+}
 
-	err = app.runner.Run(args[2:])
-	return
+func (app *App) List(prefix string) ([]string, error) {
+	return nil, errors.New("not implemented")
+}
+
+func (app *App) Copy(srcBlob string, dstBlob string) error {
+	return errors.New("not implemented")
+}
+
+func (app *App) Properties(dest string) error {
+	return errors.New("not implemented")
+}
+
+func (app *App) EnsureStorageExists() error {
+	return errors.New("not implemented")
+}
+
+func (app *App) DeleteRecursive(prefix string) error {
+	return errors.New("not implemented")
 }

dav/app/app_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"os"
 	"path/filepath"
+	"time"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -42,11 +43,15 @@ func pathToFixture(file string) string {
 }
 
 var _ = Describe("App", func() {
+
 	It("reads the CA cert from config", func() {
-		runner := &FakeRunner{}
+		configFile, _ := os.Open(pathToFixture("dav-cli-config-with-ca.json")) //nolint:errcheck
+		defer configFile.Close()                                               //nolint:errcheck
+		davConfig, _ := davconf.NewFromReader(configFile)                      //nolint:errcheck
 
-		app := New(runner)
-		err := app.Run([]string{"dav-cli", "-c", pathToFixture("dav-cli-config-with-ca.json"), "put", "localFile", "remoteFile"})
+		runner := &FakeRunner{}
+		app := New(runner, davConfig)
+		err := app.Put("localFile", "remoteFile")
 		Expect(err).ToNot(HaveOccurred())
 
 		expectedConfig := davconf.Config{
@@ -66,22 +71,30 @@ var _ = Describe("App", func() {
 	})
 
 	It("returns error if CA Cert is invalid", func() {
+		configFile, _ := os.Open(pathToFixture("dav-cli-config-with-ca.json")) //nolint:errcheck
+		defer configFile.Close()                                               //nolint:errcheck
+		davConfig, _ := davconf.NewFromReader(configFile)                      //nolint:errcheck
+
 		runner := &FakeRunner{
 			SetConfigErr: errors.New("invalid cert"),
 		}
 
-		app := New(runner)
-		err := app.Run([]string{"dav-cli", "-c", pathToFixture("dav-cli-config-with-ca.json"), "put", "localFile", "remoteFile"})
+		app := New(runner, davConfig)
+		err := app.Put("localFile", "remoteFile")
 		Expect(err).To(HaveOccurred())
 		Expect(err.Error()).To(ContainSubstring("Invalid CA Certificate: invalid cert"))
 
 	})
 
 	It("runs the put command", func() {
+		configFile, _ := os.Open(pathToFixture("dav-cli-config.json")) //nolint:errcheck
+		defer configFile.Close()                                       //nolint:errcheck
+		davConfig, _ := davconf.NewFromReader(configFile)              //nolint:errcheck
+
 		runner := &FakeRunner{}
 
-		app := New(runner)
-		err := app.Run([]string{"dav-cli", "-c", pathToFixture("dav-cli-config.json"), "put", "localFile", "remoteFile"})
+		app := New(runner, davConfig)
+		err := app.Put("localFile", "remoteFile")
 		Expect(err).ToNot(HaveOccurred())
 
 		expectedConfig := davconf.Config{
@@ -96,29 +109,58 @@ var _ = Describe("App", func() {
 		Expect(runner.RunArgs).To(Equal([]string{"put", "localFile", "remoteFile"}))
 	})
 
-	It("returns error with no config argument", func() {
-		runner := &FakeRunner{}
+	It("returns error from the cmd runner", func() {
 
-		app := New(runner)
-		err := app.Run([]string{"put", "localFile", "remoteFile"})
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("Config file arg `-c` is missing"))
-	})
-	It("prints the version info with the -v flag", func() {
-		runner := &FakeRunner{}
-		app := New(runner)
-		err := app.Run([]string{"dav-cli", "-v"})
-		Expect(err).ToNot(HaveOccurred())
-	})
+		configFile, _ := os.Open(pathToFixture("dav-cli-config.json")) //nolint:errcheck
+		defer configFile.Close()                                       //nolint:errcheck
+		davConfig, _ := davconf.NewFromReader(configFile)              //nolint:errcheck
 
-	It("returns error from the cmd runner", func() {
 		runner := &FakeRunner{
 			RunErr: errors.New("fake-run-error"),
 		}
 
-		app := New(runner)
-		err := app.Run([]string{"dav-cli", "-c", pathToFixture("dav-cli-config.json"), "put", "localFile", "remoteFile"})
+		app := New(runner, davConfig)
+		err := app.Put("localFile", "remoteFile")
 		Expect(err).To(HaveOccurred())
 		Expect(err.Error()).To(ContainSubstring("fake-run-error"))
 	})
+
+	Context("Checking functionalities", func() {
+		// var app *App
+		var davConfig davconf.Config
+		BeforeEach(func() {
+
+			configFile, _ := os.Open(pathToFixture("dav-cli-config.json")) //nolint:errcheck
+			defer configFile.Close()                                       //nolint:errcheck
+			davConfig, _ = davconf.NewFromReader(configFile)               //nolint:errcheck
+		})
+
+		It("Exists fails", func() {
+
+			runner := &FakeRunner{
+				RunErr: errors.New("object does not exist"),
+			}
+			app := New(runner, davConfig)
+
+			exist, err := app.Exists("someObject") //nolint:errcheck
+
+			Expect(err.Error()).To(ContainSubstring("object does not exist"))
+			Expect(exist).To(BeFalse())
+
+		})
+
+		It("Sign Fails", func() {
+			runner := &FakeRunner{
+				RunErr: errors.New("can't sign"),
+			}
+
+			app := New(runner, davConfig)
+			signedurl, err := app.Sign("someObject", "SomeObject", time.Second*100)
+			Expect(signedurl).To(BeEmpty())
+			Expect(err.Error()).To(ContainSubstring("can't sign"))
+
+		})
+
+	})
+
 })

dav/config/config.go

@@ -1,5 +1,10 @@
 package config
 
+import (
+	"encoding/json"
+	"io"
+)
+
 type Config struct {
 	User          string
 	Password      string
@@ -16,3 +21,19 @@ type TLS struct {
 type Cert struct {
 	CA string
 }
+
+func NewFromReader(reader io.Reader) (Config, error) {
+	config := Config{}
+
+	configBytes, err := io.ReadAll(reader)
+	if err != nil {
+		return config, err
+	}
+
+	err = json.Unmarshal(configBytes, &config)
+	if err != nil {
+		return config, err
+	}
+
+	return config, nil
+}

dav/main/dav.go

@@ -15,7 +15,7 @@ func main() {
 
 	configPath := flag.String("c", "", "configuration path")
 	showVer := flag.Bool("v", false, "version")
-	storageType := flag.String("s", "s3", "storage type: azurebs|alioss|s3|gcs")
+	storageType := flag.String("s", "s3", "storage type: azurebs|alioss|s3|gcs|dav")
 	flag.Parse()
 
 	if *showVer {
@@ -27,11 +27,13 @@ func main() {
 	if err != nil {
 		log.Fatalln(err)
 	}
+	defer configFile.Close() //nolint:errcheck
 
 	client, err := storage.NewStorageClient(*storageType, configFile)
 	if err != nil {
 		log.Fatalln(err)
 	}
+
 	sty := storage.NewStrategy(client)
 
 	nonFlagArgs := flag.Args()