0e732ce3c9aaa3df7b299c4b403493f780b3c2e5

Committed 29 May 2024 02:43PM UTC coverage: 93.174% (-1.2%) from 94.403%

Build # 0e732ce3c9aaa3df7b299c4b403493f780b3c2e5

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #32 from warmwaffles/update-for-latest-elixir

Update for latest elixir

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

8 existing lines in 5 files now uncovered.

273 of 293 relevant lines covered (93.17%)

138.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.62

/test/support/adapter_case.ex

defmodule FileStore.AdapterCase do
  @moduledoc false

  use ExUnit.CaseTemplate

  @tmp Path.join(System.tmp_dir!(), "file_store")

  setup do
    File.rm_rf!(@tmp)
    File.mkdir!(@tmp)
    {:ok, tmp: @tmp}
  end

  using do
    # credo:disable-for-this-file Credo.Check.Refactor.LongQuoteBlocks
    quote location: :keep do
      import FileStore.AdapterCase

      describe "write/4 conformance" do
        test "writes a file", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert {:ok, "bar"} = FileStore.read(store, "foo")
        end

        test "overwrites a file", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert {:ok, "bar"} = FileStore.read(store, "foo")

          assert :ok = FileStore.write(store, "foo", "baz")
          assert {:ok, "baz"} = FileStore.read(store, "foo")
        end
      end

      describe "read/2 conformance" do
        test "reads a file", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert {:ok, "bar"} = FileStore.read(store, "foo")
        end

        test "errors when file does not exist", %{store: store} do
          assert {:error, _} = FileStore.read(store, "does-not-exist")
        end
      end

      describe "upload/3 conformance" do
        test "uploads a file", %{store: store} do
          bar = write("bar.txt", "bar")

          assert :ok = FileStore.upload(store, bar, "foo")
          assert {:ok, "bar"} = FileStore.read(store, "foo")
        end

        test "overwrites a file", %{store: store} do
          bar = write("bar.txt", "bar")
          baz = write("baz.txt", "baz")

          assert :ok = FileStore.upload(store, bar, "foo")
          assert {:ok, "bar"} = FileStore.read(store, "foo")

          assert :ok = FileStore.upload(store, baz, "foo")
          assert {:ok, "baz"} = FileStore.read(store, "foo")
        end

        test "fails when the source file is missing", %{store: store} do
          assert {:error, _} = FileStore.upload(store, "doesnotexist.txt", "foo")
        end
      end

      describe "download/3 conformance" do
        test "downloads a file", %{store: store} do
          download = join("download.txt")

          assert :ok = FileStore.write(store, "foo", "bar")
          assert :ok = FileStore.download(store, "foo", download)
          assert File.read!(download) == "bar"
        end
      end

      describe "stat/2 conformance" do
        test "retrieves file info", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert {:ok, stat} = FileStore.stat(store, "foo")
          assert stat.key == "foo"
          assert stat.size == 3
          assert stat.etag == "37b51d194a7513e45b56f6524f2d51f2"
        end

        test "fails when the file is missing", %{store: store} do
          assert {:error, _} = FileStore.stat(store, "completegarbage")
        end
      end

      describe "delete/2 conformance" do
        test "deletes the file", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert :ok = FileStore.delete(store, "foo")
        end

        test "indicates success for non-existent keys", %{store: store} do
          assert :ok = FileStore.delete(store, "non-existent")
          assert :ok = FileStore.delete(store, "non/existent")
        end
      end

      describe "delete_all/2 conformance" do
        test "deletes all files", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "")
          assert :ok = FileStore.write(store, "bar/buzz", "")
          assert :ok = FileStore.delete_all(store)
          assert {:error, _} = FileStore.stat(store, "foo")
          assert {:error, _} = FileStore.stat(store, "bar/buzz")
        end

        test "deletes files under prefix", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "")
          assert :ok = FileStore.write(store, "bar/buzz", "")
          assert :ok = FileStore.write(store, "bar/baz", "")
          assert :ok = FileStore.delete_all(store, prefix: "bar")
          assert {:ok, _} = FileStore.stat(store, "foo")
          assert {:error, _} = FileStore.stat(store, "bar/buzz")
          assert {:error, _} = FileStore.stat(store, "bar/baz")
        end

        test "indicates success for non-existent keys", %{store: store} do
          assert :ok = FileStore.delete_all(store, prefix: "non-existent")
        end
      end

      describe "get_public_url/3 conformance" do
        test "returns a URL", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert url = FileStore.get_public_url(store, "foo")
          assert valid_url?(url)
        end
      end

      describe "get_signed_url/3 conformance" do
        test "returns a URL", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "bar")
          assert {:ok, url} = FileStore.get_signed_url(store, "foo")
          assert valid_url?(url)
        end
      end

      describe "list!/2 conformance" do
        test "lists keys in the store", %{store: store} do
          assert :ok = FileStore.write(store, "foo", "")
          assert "foo" in Enum.to_list(FileStore.list!(store))
        end

        test "lists nested keys in the store", %{store: store} do
          assert :ok = FileStore.write(store, "foo/bar", "")
          assert "foo/bar" in Enum.to_list(FileStore.list!(store))
        end

        test "lists keys matching prefix", %{store: store} do
          assert :ok = FileStore.write(store, "bar", "")
          assert :ok = FileStore.write(store, "foo/bar", "")

          keys = Enum.to_list(FileStore.list!(store, prefix: "foo"))
          refute "bar" in keys
          assert "foo/bar" in keys
        end
      end

      describe "copy/3 conformance" do
        test "copies a file", %{store: store} do
          :ok = FileStore.write(store, "foo", "test")

          assert :ok = FileStore.copy(store, "foo", "bar")
          assert {:ok, "test"} = FileStore.read(store, "foo")
        end

        test "fails to copy a non existing file", %{store: store} do
          assert {:error, _} = FileStore.copy(store, "foo", "bar")
          assert {:error, _} = FileStore.stat(store, "bar")
        end

        test "copy replaces existing file", %{store: store} do
          :ok = FileStore.write(store, "foo", "test")
          :ok = FileStore.write(store, "bar", "i exist")

          assert :ok = FileStore.copy(store, "foo", "bar")
          assert {:ok, "test"} = FileStore.read(store, "bar")
        end
      end

      describe "rename/3 conformance" do
        test "renames a file", %{store: store} do
          :ok = FileStore.write(store, "foo", "test")

          assert :ok = FileStore.rename(store, "foo", "bar")
          assert {:error, _} = FileStore.stat(store, "foo")
          assert {:ok, _} = FileStore.stat(store, "bar")
        end

        test "fails to rename a non existing file", %{store: store} do
          assert {:error, _} = FileStore.rename(store, "foo", "bar")
          assert {:error, _} = FileStore.stat(store, "bar")
        end

        test "rename replaces existing file", %{store: store} do
          :ok = FileStore.write(store, "foo", "test")
          :ok = FileStore.write(store, "bar", "i exist")

          assert :ok = FileStore.rename(store, "foo", "bar")
          assert {:error, _} = FileStore.stat(store, "foo")
          assert {:ok, _} = FileStore.stat(store, "bar")
        end
      end
    end
  end

  def join(name) do
    Path.join(@tmp, name)
  end

  def write(name, data) do
    path = join(name)
    File.write!(path, data)
    path
  end

  def valid_url?(value) do
    case URI.parse(value) do
      %URI{scheme: nil} -> false
      %URI{host: nil} -> false
      %URI{scheme: scheme} -> scheme =~ ~r"^https?$"
    end
  end

  def get_query(url, param) do
    url
    |> URI.parse()
    |> Map.fetch!(:query)
    |> URI.decode_query()
    |> Map.fetch!(param)
  end

  def omit_query(url) do
    url
    |> URI.parse()
    |> Map.put(:query, nil)
    |> URI.to_string()
  end
end

1	defmodule FileStore.AdapterCase do
2	@moduledoc false
3
4	use ExUnit.CaseTemplate
5
6	@tmp Path.join(System.tmp_dir!(), "file_store")
7
8	setup do
9	File.rm_rf!(@tmp)	1,647✔
10	File.mkdir!(@tmp)	1,647✔
11	{:ok, tmp: @tmp}
12	end
13
14	using do	54✔
15	# credo:disable-for-this-file Credo.Check.Refactor.LongQuoteBlocks
16	quote location: :keep do
17	import FileStore.AdapterCase
18
19	describe "write/4 conformance" do
20	test "writes a file", %{store: store} do
21	assert :ok = FileStore.write(store, "foo", "bar")
22	assert {:ok, "bar"} = FileStore.read(store, "foo")
23	end
24
25	test "overwrites a file", %{store: store} do
26	assert :ok = FileStore.write(store, "foo", "bar")
27	assert {:ok, "bar"} = FileStore.read(store, "foo")
28
29	assert :ok = FileStore.write(store, "foo", "baz")
30	assert {:ok, "baz"} = FileStore.read(store, "foo")
31	end
32	end
33
34	describe "read/2 conformance" do
35	test "reads a file", %{store: store} do
36	assert :ok = FileStore.write(store, "foo", "bar")
37	assert {:ok, "bar"} = FileStore.read(store, "foo")
38	end
39
40	test "errors when file does not exist", %{store: store} do
41	assert {:error, _} = FileStore.read(store, "does-not-exist")
42	end
43	end
44
45	describe "upload/3 conformance" do
46	test "uploads a file", %{store: store} do
47	bar = write("bar.txt", "bar")
48
49	assert :ok = FileStore.upload(store, bar, "foo")
50	assert {:ok, "bar"} = FileStore.read(store, "foo")
51	end
52
53	test "overwrites a file", %{store: store} do
54	bar = write("bar.txt", "bar")
55	baz = write("baz.txt", "baz")
56
57	assert :ok = FileStore.upload(store, bar, "foo")
58	assert {:ok, "bar"} = FileStore.read(store, "foo")
59
60	assert :ok = FileStore.upload(store, baz, "foo")
61	assert {:ok, "baz"} = FileStore.read(store, "foo")
62	end
63
64	test "fails when the source file is missing", %{store: store} do
65	assert {:error, _} = FileStore.upload(store, "doesnotexist.txt", "foo")
66	end
67	end
68
69	describe "download/3 conformance" do
70	test "downloads a file", %{store: store} do
71	download = join("download.txt")
72
73	assert :ok = FileStore.write(store, "foo", "bar")
74	assert :ok = FileStore.download(store, "foo", download)
75	assert File.read!(download) == "bar"
76	end
77	end
78
79	describe "stat/2 conformance" do
80	test "retrieves file info", %{store: store} do
81	assert :ok = FileStore.write(store, "foo", "bar")
82	assert {:ok, stat} = FileStore.stat(store, "foo")
83	assert stat.key == "foo"
84	assert stat.size == 3
85	assert stat.etag == "37b51d194a7513e45b56f6524f2d51f2"
86	end
87
88	test "fails when the file is missing", %{store: store} do
89	assert {:error, _} = FileStore.stat(store, "completegarbage")
90	end
91	end
92
93	describe "delete/2 conformance" do
94	test "deletes the file", %{store: store} do
95	assert :ok = FileStore.write(store, "foo", "bar")
96	assert :ok = FileStore.delete(store, "foo")
97	end
98
99	test "indicates success for non-existent keys", %{store: store} do
100	assert :ok = FileStore.delete(store, "non-existent")
101	assert :ok = FileStore.delete(store, "non/existent")
102	end
103	end
104
105	describe "delete_all/2 conformance" do
106	test "deletes all files", %{store: store} do
107	assert :ok = FileStore.write(store, "foo", "")
108	assert :ok = FileStore.write(store, "bar/buzz", "")
109	assert :ok = FileStore.delete_all(store)
110	assert {:error, _} = FileStore.stat(store, "foo")
111	assert {:error, _} = FileStore.stat(store, "bar/buzz")
112	end
113
114	test "deletes files under prefix", %{store: store} do
115	assert :ok = FileStore.write(store, "foo", "")
116	assert :ok = FileStore.write(store, "bar/buzz", "")
117	assert :ok = FileStore.write(store, "bar/baz", "")
118	assert :ok = FileStore.delete_all(store, prefix: "bar")
119	assert {:ok, _} = FileStore.stat(store, "foo")
120	assert {:error, _} = FileStore.stat(store, "bar/buzz")
121	assert {:error, _} = FileStore.stat(store, "bar/baz")
122	end
123
124	test "indicates success for non-existent keys", %{store: store} do
125	assert :ok = FileStore.delete_all(store, prefix: "non-existent")
126	end
127	end
128
129	describe "get_public_url/3 conformance" do
130	test "returns a URL", %{store: store} do
131	assert :ok = FileStore.write(store, "foo", "bar")
132	assert url = FileStore.get_public_url(store, "foo")
133	assert valid_url?(url)
134	end
135	end
136
137	describe "get_signed_url/3 conformance" do
138	test "returns a URL", %{store: store} do
139	assert :ok = FileStore.write(store, "foo", "bar")
140	assert {:ok, url} = FileStore.get_signed_url(store, "foo")
141	assert valid_url?(url)
142	end
143	end
144
145	describe "list!/2 conformance" do
146	test "lists keys in the store", %{store: store} do
147	assert :ok = FileStore.write(store, "foo", "")
148	assert "foo" in Enum.to_list(FileStore.list!(store))
149	end
150
151	test "lists nested keys in the store", %{store: store} do
152	assert :ok = FileStore.write(store, "foo/bar", "")
153	assert "foo/bar" in Enum.to_list(FileStore.list!(store))
154	end
155
156	test "lists keys matching prefix", %{store: store} do
157	assert :ok = FileStore.write(store, "bar", "")
158	assert :ok = FileStore.write(store, "foo/bar", "")
159
160	keys = Enum.to_list(FileStore.list!(store, prefix: "foo"))
161	refute "bar" in keys
162	assert "foo/bar" in keys
163	end
164	end
165
166	describe "copy/3 conformance" do
167	test "copies a file", %{store: store} do
168	:ok = FileStore.write(store, "foo", "test")
169
170	assert :ok = FileStore.copy(store, "foo", "bar")
171	assert {:ok, "test"} = FileStore.read(store, "foo")
172	end
173
174	test "fails to copy a non existing file", %{store: store} do
175	assert {:error, _} = FileStore.copy(store, "foo", "bar")
176	assert {:error, _} = FileStore.stat(store, "bar")
177	end
178
179	test "copy replaces existing file", %{store: store} do
180	:ok = FileStore.write(store, "foo", "test")
181	:ok = FileStore.write(store, "bar", "i exist")
182
183	assert :ok = FileStore.copy(store, "foo", "bar")
184	assert {:ok, "test"} = FileStore.read(store, "bar")
185	end
186	end
187
188	describe "rename/3 conformance" do
189	test "renames a file", %{store: store} do
190	:ok = FileStore.write(store, "foo", "test")
191
192	assert :ok = FileStore.rename(store, "foo", "bar")
193	assert {:error, _} = FileStore.stat(store, "foo")
194	assert {:ok, _} = FileStore.stat(store, "bar")
195	end
196
197	test "fails to rename a non existing file", %{store: store} do
198	assert {:error, _} = FileStore.rename(store, "foo", "bar")
199	assert {:error, _} = FileStore.stat(store, "bar")
200	end
201
202	test "rename replaces existing file", %{store: store} do
203	:ok = FileStore.write(store, "foo", "test")
204	:ok = FileStore.write(store, "bar", "i exist")
205
206	assert :ok = FileStore.rename(store, "foo", "bar")
207	assert {:error, _} = FileStore.stat(store, "foo")
208	assert {:ok, _} = FileStore.stat(store, "bar")
209	end
210	end
211	end
212	end
213
214	def join(name) do
215	Path.join(@tmp, name)	216✔
216	end
217
218	def write(name, data) do
219	path = join(name)	162✔
220	File.write!(path, data)	162✔
221	path	162✔
222	end
223
224	def valid_url?(value) do
225	case URI.parse(value) do	108✔
UNCOV 226	%URI{scheme: nil} -> false	×
UNCOV 227	%URI{host: nil} -> false	×
228	%URI{scheme: scheme} -> scheme =~ ~r"^https?$"	108✔
229	end
230	end
231
232	def get_query(url, param) do
233	url
234	\|> URI.parse()
235	\|> Map.fetch!(:query)
236	\|> URI.decode_query()
237	\|> Map.fetch!(param)	135✔
238	end
239
240	def omit_query(url) do
241	url
242	\|> URI.parse()
243	\|> Map.put(:query, nil)
244	\|> URI.to_string()	72✔
245	end
246	end

rzane / file_store / 0e732ce3c9aaa3df7b299c4b403493f780b3c2e5

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous