fedi/akkoma
1
0
Fork 0
mirror of https://akkoma.dev/AkkomaGang/akkoma.git synced 2024-12-23 01:35:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

removing integration tests

Browse source
This commit is contained in:
Alexander Strizhakov 2020-03-05 18:57:45 +03:00
parent 058c9b01ac
commit 931111fd55
No known key found for this signature in database
GPG key ID: 022896A53AEF1381
4 changed files with 0 additions and 460 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
test/http_test.exs
View file

@ -58,29 +58,4 @@ defmodule Pleroma.HTTPTest do
}
end
end
describe "connection pools" do
@describetag :integration
clear_config(Pleroma.Gun) do
Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
end
test "gun" do
adapter = Application.get_env(:tesla, :adapter)
Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)
on_exit(fn ->
Application.put_env(:tesla, :adapter, adapter)
end)
options = [adapter: [pool: :federation]]
assert {:ok, resp} = HTTP.get("https://httpbin.org/user-agent", [], options)
assert resp.status == 200
state = Pleroma.Pool.Connections.get_state(:gun_connections)
assert state.conns["https:httpbin.org:443"]
end
end
end

301
test/pool/connections_test.exs
View file

@ -435,307 +435,6 @@ defmodule Pleroma.Pool.ConnectionsTest do
} = Connections.get_state(name)
end
describe "integration test" do
@describetag :integration
clear_config(Pleroma.Gun) do
Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
end
test "opens connection and change owner", %{name: name} do
url = "https://httpbin.org"
:ok = Conn.open(url, name)
conn = Connections.checkin(url, name)
pid = Process.whereis(name)
assert :gun.info(conn).owner == pid
end
test "opens connection and reuse it on next request", %{name: name} do
url = "http://httpbin.org"
:ok = Conn.open(url, name)
Process.sleep(250)
conn = Connections.checkin(url, name)
assert is_pid(conn)
assert Process.alive?(conn)
reused_conn = Connections.checkin(url, name)
assert conn == reused_conn
%Connections{
conns: %{
"http:httpbin.org:80" => %Conn{
conn: ^conn,
gun_state: :up
}
}
} = Connections.get_state(name)
end
test "opens ssl connection and reuse it on next request", %{name: name} do
url = "https://httpbin.org"
:ok = Conn.open(url, name)
Process.sleep(1_000)
conn = Connections.checkin(url, name)
assert is_pid(conn)
assert Process.alive?(conn)
reused_conn = Connections.checkin(url, name)
assert conn == reused_conn
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: ^conn,
gun_state: :up
}
}
} = Connections.get_state(name)
end
test "remove frequently used and idle", %{name: name} do
self = self()
https1 = "https://www.google.com"
https2 = "https://httpbin.org"
:ok = Conn.open(https1, name)
:ok = Conn.open(https2, name)
Process.sleep(1_500)
conn = Connections.checkin(https1, name)
for _ <- 1..4 do
Connections.checkin(https2, name)
end
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: _,
gun_state: :up
},
"https:www.google.com:443" => %Conn{
conn: _,
gun_state: :up
}
}
} = Connections.get_state(name)
:ok = Connections.checkout(conn, self, name)
http = "http://httpbin.org"
Process.sleep(1_000)
:ok = Conn.open(http, name)
conn = Connections.checkin(http, name)
%Connections{
conns: %{
"http:httpbin.org:80" => %Conn{
conn: ^conn,
gun_state: :up
},
"https:httpbin.org:443" => %Conn{
conn: _,
gun_state: :up
}
}
} = Connections.get_state(name)
end
test "remove earlier used and idle", %{name: name} do
self = self()
https1 = "https://www.google.com"
https2 = "https://httpbin.org"
:ok = Conn.open(https1, name)
:ok = Conn.open(https2, name)
Process.sleep(1_500)
Connections.checkin(https1, name)
conn = Connections.checkin(https1, name)
Process.sleep(1_000)
Connections.checkin(https2, name)
Connections.checkin(https2, name)
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: _,
gun_state: :up
},
"https:www.google.com:443" => %Conn{
conn: ^conn,
gun_state: :up
}
}
} = Connections.get_state(name)
:ok = Connections.checkout(conn, self, name)
:ok = Connections.checkout(conn, self, name)
http = "http://httpbin.org"
:ok = Conn.open(http, name)
Process.sleep(1_000)
conn = Connections.checkin(http, name)
%Connections{
conns: %{
"http:httpbin.org:80" => %Conn{
conn: ^conn,
gun_state: :up
},
"https:httpbin.org:443" => %Conn{
conn: _,
gun_state: :up
}
}
} = Connections.get_state(name)
end
test "doesn't open new conn on pool overflow", %{name: name} do
self = self()
https1 = "https://www.google.com"
https2 = "https://httpbin.org"
:ok = Conn.open(https1, name)
:ok = Conn.open(https2, name)
Process.sleep(1_000)
Connections.checkin(https1, name)
conn1 = Connections.checkin(https1, name)
conn2 = Connections.checkin(https2, name)
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: ^conn2,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}]
},
"https:www.google.com:443" => %Conn{
conn: ^conn1,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}, {^self, _}]
}
}
} = Connections.get_state(name)
refute Connections.checkin("http://httpbin.org", name)
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: ^conn2,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}]
},
"https:www.google.com:443" => %Conn{
conn: ^conn1,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}, {^self, _}]
}
}
} = Connections.get_state(name)
end
test "get idle connection with the smallest crf", %{
name: name
} do
self = self()
https1 = "https://www.google.com"
https2 = "https://httpbin.org"
:ok = Conn.open(https1, name)
:ok = Conn.open(https2, name)
Process.sleep(1_500)
Connections.checkin(https1, name)
Connections.checkin(https2, name)
Connections.checkin(https1, name)
conn1 = Connections.checkin(https1, name)
conn2 = Connections.checkin(https2, name)
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: ^conn2,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}, {^self, _}],
crf: crf2
},
"https:www.google.com:443" => %Conn{
conn: ^conn1,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}, {^self, _}, {^self, _}],
crf: crf1
}
}
} = Connections.get_state(name)
assert crf1 > crf2
:ok = Connections.checkout(conn1, self, name)
:ok = Connections.checkout(conn1, self, name)
:ok = Connections.checkout(conn1, self, name)
:ok = Connections.checkout(conn2, self, name)
:ok = Connections.checkout(conn2, self, name)
%Connections{
conns: %{
"https:httpbin.org:443" => %Conn{
conn: ^conn2,
gun_state: :up,
conn_state: :idle,
used_by: []
},
"https:www.google.com:443" => %Conn{
conn: ^conn1,
gun_state: :up,
conn_state: :idle,
used_by: []
}
}
} = Connections.get_state(name)
http = "http://httpbin.org"
:ok = Conn.open(http, name)
Process.sleep(1_000)
conn = Connections.checkin(http, name)
%Connections{
conns: %{
"https:www.google.com:443" => %Conn{
conn: ^conn1,
gun_state: :up,
conn_state: :idle,
used_by: [],
crf: crf1
},
"http:httpbin.org:80" => %Conn{
conn: ^conn,
gun_state: :up,
conn_state: :active,
used_by: [{^self, _}],
crf: crf
}
}
} = Connections.get_state(name)
assert crf1 > crf
end
end
describe "with proxy" do
test "as ip", %{name: name} do
url = "http://proxy-string.com"

93
test/reverse_proxy/client/tesla_test.exs
View file

@ -1,93 +0,0 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.ReverseProxy.Client.TeslaTest do
use ExUnit.Case
use Pleroma.Tests.Helpers
alias Pleroma.ReverseProxy.Client
@moduletag :integration
clear_config_all(Pleroma.Gun) do
Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
end
setup do
Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)
on_exit(fn ->
Application.put_env(:tesla, :adapter, Tesla.Mock)
end)
end
test "get response body stream" do
{:ok, status, headers, ref} =
Client.Tesla.request(
:get,
"http://httpbin.org/stream-bytes/10",
[{"accept", "application/octet-stream"}],
"",
[]
)
assert status == 200
assert headers != []
{:ok, response, ref} = Client.Tesla.stream_body(ref)
check_ref(ref)
assert is_binary(response)
assert byte_size(response) == 10
assert :done == Client.Tesla.stream_body(ref)
assert :ok = Client.Tesla.close(ref)
end
test "head response" do
{:ok, status, headers} = Client.Tesla.request(:head, "https://httpbin.org/get", [], "")
assert status == 200
assert headers != []
end
test "get error response" do
{:ok, status, headers, _body} =
Client.Tesla.request(
:get,
"https://httpbin.org/status/500",
[],
""
)
assert status == 500
assert headers != []
end
describe "client error" do
setup do
adapter = Application.get_env(:tesla, :adapter)
Application.put_env(:tesla, :adapter, Tesla.Adapter.Hackney)
on_exit(fn -> Application.put_env(:tesla, :adapter, adapter) end)
:ok
end
test "adapter doesn't support reading body in chunks" do
assert_raise RuntimeError,
"Elixir.Tesla.Adapter.Hackney doesn't support reading body in chunks",
fn ->
Client.Tesla.request(
:get,
"http://httpbin.org/stream-bytes/10",
[{"accept", "application/octet-stream"}],
""
)
end
end
end
defp check_ref(%{pid: pid, stream: stream} = ref) do
assert is_pid(pid)
assert is_reference(stream)
assert ref[:fin]
end
end

41
test/reverse_proxy/reverse_proxy_test.exs
View file

@ -341,45 +341,4 @@ defmodule Pleroma.ReverseProxyTest do
assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
end
end
describe "tesla client using gun integration" do
@describetag :integration
clear_config(Pleroma.ReverseProxy.Client) do
Pleroma.Config.put(Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.Client.Tesla)
end
clear_config(Pleroma.Gun) do
Pleroma.Config.put(Pleroma.Gun, Pleroma.Gun.API)
end
setup do
adapter = Application.get_env(:tesla, :adapter)
Application.put_env(:tesla, :adapter, Tesla.Adapter.Gun)
on_exit(fn ->
Application.put_env(:tesla, :adapter, adapter)
end)
end
test "common", %{conn: conn} do
conn = ReverseProxy.call(conn, "http://httpbin.org/stream-bytes/10")
assert byte_size(conn.resp_body) == 10
assert conn.state == :chunked
assert conn.status == 200
end
test "ssl", %{conn: conn} do
conn = ReverseProxy.call(conn, "https://httpbin.org/stream-bytes/10")
assert byte_size(conn.resp_body) == 10
assert conn.state == :chunked
assert conn.status == 200
end
test "follow redirects", %{conn: conn} do
conn = ReverseProxy.call(conn, "https://httpbin.org/redirect/5")
assert conn.state == :chunked
assert conn.status == 200
end
end
end