filecache/dropbox_test.go at master · Nitro/filecache · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package filecache_test

import (
	"encoding/base64"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"time"

	. "github.com/Nitro/filecache"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

type dummyWriter struct {
	receivedData string
	writeError   error
}

func (dw *dummyWriter) Write(p []byte) (n int, err error) {
	if dw.writeError != nil {
		return 0, dw.writeError
	}

	dw.receivedData = string(p)
	return len(p), nil
}

var _ = Describe("DropboxDownload", func() {
	It("downloads a file successfully", func() {
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			_, err := w.Write([]byte("dummy_content"))
			Expect(err).To(BeNil())
		}))
		defer ts.Close()
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.RawURLEncoding.EncodeToString([]byte(ts.URL)),
		)

		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		writer := &dummyWriter{}
		err = DropboxDownload(dr, writer, 100*time.Millisecond)
		Expect(err).ShouldNot(HaveOccurred())
		Expect(writer.receivedData).To(ContainSubstring("dummy_content"))
	})

	It("fails to decode an invalid base64-encoded Dropbox URL", func() {
		dr, err := NewDownloadRecord("dropbox/foo.bar", nil)
		Expect(err).To(BeNil())

		err = DropboxDownload(dr, &dummyWriter{}, 100*time.Millisecond)
		Expect(err).Should(HaveOccurred())
	})

	It("fails to decode an URL encoded with an invalid base64-encoding", func() {
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.StdEncoding.EncodeToString([]byte("http://dropbox.com/foo.bar")),
		)
		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		err = DropboxDownload(dr, &dummyWriter{}, 100*time.Millisecond)
		Expect(err).Should(HaveOccurred())
	})

	It("fails to create a HTTP request for an invalid URL", func() {
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.RawURLEncoding.EncodeToString([]byte("ht$tp://invalid_url")),
		)

		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		err = DropboxDownload(dr, &dummyWriter{}, 100*time.Millisecond)
		Expect(err).Should(HaveOccurred())
	})

	It("returns an error when trying to download from an unreachable domain", func() {
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.RawURLEncoding.EncodeToString([]byte("http://some_dummy_domain.com")),
		)

		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		err = DropboxDownload(dr, &dummyWriter{}, 100*time.Millisecond)
		Expect(err).Should(HaveOccurred())
	})

	It("returns an error when streaming the file to disk fails", func() {
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			_, err := w.Write([]byte("dummy_content"))
			Expect(err).To(BeNil())
		}))
		defer ts.Close()
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.RawURLEncoding.EncodeToString([]byte(ts.URL)),
		)

		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		writer := &dummyWriter{writeError: errors.New("dummy_error")}
		err = DropboxDownload(dr, writer, 100*time.Millisecond)
		Expect(err).Should(HaveOccurred())
		Expect(err.Error()).To(ContainSubstring("dummy_error"))
	})

	It("fails to download when timing out", func() {
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			_, err := w.Write([]byte("dummy_content"))
			Expect(err).To(BeNil())
		}))
		defer ts.Close()
		url := fmt.Sprintf(
			"dropbox/%s",
			base64.RawURLEncoding.EncodeToString([]byte(ts.URL)),
		)

		dr, err := NewDownloadRecord(url, nil)
		Expect(err).To(BeNil())

		writer := &dummyWriter{}
		err = DropboxDownload(dr, writer, 0*time.Millisecond)
		Expect(err).Should(HaveOccurred())
		Expect(err.Error()).To(ContainSubstring("context deadline exceeded"))
	})
})