Implement Copy, List, DeleteRecursive, Properties for DAV

dav/client/client.go

@@ -122,27 +122,27 @@ func (d *DavBlobstore) Sign(dest string, action string, expiration time.Duration
 	}
 }
 
-// DeleteRecursive is not yet implemented in this refactoring
 func (d *DavBlobstore) DeleteRecursive(prefix string) error {
-	return fmt.Errorf("DeleteRecursive not yet implemented")
+	slog.Info("deleting blobs recursively from webdav", "prefix", prefix)
+	return d.storageClient.DeleteRecursive(prefix)
 }
 
-// List is not yet implemented in this refactoring
 func (d *DavBlobstore) List(prefix string) ([]string, error) {
-	return nil, fmt.Errorf("List not yet implemented")
+	slog.Info("listing blobs on webdav", "prefix", prefix)
+	return d.storageClient.List(prefix)
 }
 
-// Copy is not yet implemented in this refactoring
 func (d *DavBlobstore) Copy(srcBlob string, dstBlob string) error {
-	return fmt.Errorf("Copy not yet implemented")
+	slog.Info("copying blob on webdav", "src", srcBlob, "dst", dstBlob)
+	return d.storageClient.Copy(srcBlob, dstBlob)
 }
 
-// Properties is not yet implemented in this refactoring
 func (d *DavBlobstore) Properties(dest string) error {
-	return fmt.Errorf("Properties not yet implemented")
+	slog.Info("fetching blob properties from webdav", "dest", dest)
+	return d.storageClient.Properties(dest)
 }
 
-// EnsureStorageExists is not yet implemented in this refactoring
 func (d *DavBlobstore) EnsureStorageExists() error {
-	return fmt.Errorf("EnsureStorageExists not yet implemented")
+	slog.Info("ensuring webdav storage root exists")
+	return d.storageClient.EnsureStorageExists()
 }

dav/client/client_test.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/cloudfoundry/storage-cli/dav/client"
 	"github.com/cloudfoundry/storage-cli/dav/client/clientfakes"
@@ -124,4 +125,193 @@ var _ = Describe("Client", func() {
 			Expect(exists).To(BeFalse())
 		})
 	})
+
+	Context("Sign", func() {
+		var expiry = 100 * time.Second
+
+		It("returns a signed URL for action 'get'", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.SignReturns("https://the-signed-url", nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			url, err := davBlobstore.Sign("blob/path", "get", expiry)
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(url).To(Equal("https://the-signed-url"))
+
+			Expect(fakeStorageClient.SignCallCount()).To(Equal(1))
+			object, action, expiration := fakeStorageClient.SignArgsForCall(0)
+			Expect(object).To(Equal("blob/path"))
+			Expect(action).To(Equal("GET"))
+			Expect(expiration).To(Equal(expiry))
+		})
+
+		It("returns a signed URL for action 'put'", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.SignReturns("https://the-signed-url", nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			url, err := davBlobstore.Sign("blob/path", "put", expiry)
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(url).To(Equal("https://the-signed-url"))
+
+			_, action, _ := fakeStorageClient.SignArgsForCall(0)
+			Expect(action).To(Equal("PUT"))
+		})
+
+		It("fails on unknown action without calling the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			url, err := davBlobstore.Sign("blob/path", "unknown", expiry)
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("action not implemented"))
+			Expect(url).To(Equal(""))
+			Expect(fakeStorageClient.SignCallCount()).To(Equal(0))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.SignReturns("", fmt.Errorf("boom"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			url, err := davBlobstore.Sign("blob/path", "get", expiry)
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("boom"))
+			Expect(url).To(Equal(""))
+		})
+	})
+
+	Context("Copy", func() {
+		It("forwards source and destination to the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.CopyReturns(nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.Copy("src/blob", "dst/blob")
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeStorageClient.CopyCallCount()).To(Equal(1))
+
+			src, dst := fakeStorageClient.CopyArgsForCall(0)
+			Expect(src).To(Equal("src/blob"))
+			Expect(dst).To(Equal("dst/blob"))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.CopyReturns(fmt.Errorf("copy failed"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.Copy("src/blob", "dst/blob")
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("copy failed"))
+		})
+	})
+
+	Context("List", func() {
+		It("returns the blobs reported by the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.ListReturns([]string{"a/b/c", "a/b/d"}, nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			blobs, err := davBlobstore.List("a/b")
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(blobs).To(ConsistOf("a/b/c", "a/b/d"))
+
+			Expect(fakeStorageClient.ListCallCount()).To(Equal(1))
+			Expect(fakeStorageClient.ListArgsForCall(0)).To(Equal("a/b"))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.ListReturns(nil, fmt.Errorf("list failed"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			blobs, err := davBlobstore.List("any/prefix")
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("list failed"))
+			Expect(blobs).To(BeNil())
+		})
+	})
+
+	Context("DeleteRecursive", func() {
+		It("forwards the prefix to the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.DeleteRecursiveReturns(nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.DeleteRecursive("some/prefix")
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeStorageClient.DeleteRecursiveCallCount()).To(Equal(1))
+			Expect(fakeStorageClient.DeleteRecursiveArgsForCall(0)).To(Equal("some/prefix"))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.DeleteRecursiveReturns(fmt.Errorf("recursive delete failed"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.DeleteRecursive("some/prefix")
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("recursive delete failed"))
+		})
+	})
+
+	Context("Properties", func() {
+		It("forwards the destination to the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.PropertiesReturns(nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.Properties("blob/path")
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeStorageClient.PropertiesCallCount()).To(Equal(1))
+			Expect(fakeStorageClient.PropertiesArgsForCall(0)).To(Equal("blob/path"))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.PropertiesReturns(fmt.Errorf("properties failed"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.Properties("blob/path")
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("properties failed"))
+		})
+	})
+
+	Context("EnsureStorageExists", func() {
+		It("delegates to the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.EnsureStorageExistsReturns(nil)
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.EnsureStorageExists()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fakeStorageClient.EnsureStorageExistsCallCount()).To(Equal(1))
+		})
+
+		It("propagates errors from the storage client", func() {
+			fakeStorageClient := &clientfakes.FakeStorageClient{}
+			fakeStorageClient.EnsureStorageExistsReturns(fmt.Errorf("ensure failed"))
+
+			davBlobstore := client.NewWithStorageClient(fakeStorageClient)
+			err := davBlobstore.EnsureStorageExists()
+
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("ensure failed"))
+		})
+	})
 })