swh:1:snp:eb70f1f85391e4b077c211bec36af0061c4bf937
Tip revision: 3e80cea14040807c4834eb14537f986a955e80ab authored by Jenkins for Software Heritage on 04 June 2020, 14:56:54 UTC
Updated debian changelog for version 0.1.1
Updated debian changelog for version 0.1.1
Tip revision: 3e80cea
test_retry.py
# Copyright (C) 2020 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU General Public License version 3, or any later version
# See top-level LICENSE file for more information
from unittest.mock import call
import psycopg2
import pytest
from swh.model.model import (
Content,
Directory,
Release,
Revision,
Snapshot,
SkippedContent,
Origin,
)
from swh.storage import get_storage
from swh.storage.exc import HashCollision, StorageArgumentException
from .storage_data import date_visit1
@pytest.fixture
def monkeypatch_sleep(monkeypatch, swh_storage):
"""In test context, we don't want to wait, make test faster
"""
from swh.storage.retry import RetryingProxyStorage
for method_name, method in RetryingProxyStorage.__dict__.items():
if "_add" in method_name or "_update" in method_name:
monkeypatch.setattr(method.retry, "sleep", lambda x: None)
return monkeypatch
@pytest.fixture
def fake_hash_collision(sample_data):
return HashCollision("sha1", "38762cf7f55934b34d179ae6a4c80cadccbb7f0a", [])
@pytest.fixture
def swh_storage():
storage_config = {
"cls": "pipeline",
"steps": [{"cls": "validate"}, {"cls": "retry"}, {"cls": "memory"},],
}
return get_storage(**storage_config)
def test_retrying_proxy_storage_content_add(swh_storage, sample_data):
"""Standard content_add works as before
"""
sample_content = sample_data["content"][0]
content = next(swh_storage.content_get([sample_content["sha1"]]))
assert not content
s = swh_storage.content_add([sample_content])
assert s == {
"content:add": 1,
"content:add:bytes": sample_content["length"],
}
content = next(swh_storage.content_get([sample_content["sha1"]]))
assert content["sha1"] == sample_content["sha1"]
def test_retrying_proxy_storage_content_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision,
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.content_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("content already inserted"),
# ok then!
{"content:add": 1},
]
sample_content = sample_data["content"][0]
content = next(swh_storage.content_get([sample_content["sha1"]]))
assert not content
s = swh_storage.content_add([sample_content])
assert s == {"content:add": 1}
mock_memory.assert_has_calls(
[
call([Content.from_dict(sample_content)]),
call([Content.from_dict(sample_content)]),
call([Content.from_dict(sample_content)]),
]
)
def test_retrying_proxy_swh_storage_content_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.content_add")
mock_memory.side_effect = StorageArgumentException("Refuse to add content always!")
sample_content = sample_data["content"][0]
content = next(swh_storage.content_get([sample_content["sha1"]]))
assert not content
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.content_add([sample_content])
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_content_add_metadata(swh_storage, sample_data):
"""Standard content_add_metadata works as before
"""
sample_content = sample_data["content_metadata"][0]
pk = sample_content["sha1"]
content_metadata = swh_storage.content_get_metadata([pk])
assert not content_metadata[pk]
s = swh_storage.content_add_metadata([sample_content])
assert s == {
"content:add": 1,
}
content_metadata = swh_storage.content_get_metadata([pk])
assert len(content_metadata[pk]) == 1
assert content_metadata[pk][0]["sha1"] == pk
def test_retrying_proxy_storage_content_add_metadata_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.content_add_metadata"
)
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("content_metadata already inserted"),
# ok then!
{"content:add": 1},
]
sample_content = sample_data["content_metadata"][0]
s = swh_storage.content_add_metadata([sample_content])
assert s == {"content:add": 1}
mock_memory.assert_has_calls(
[
call([Content.from_dict(sample_content)]),
call([Content.from_dict(sample_content)]),
call([Content.from_dict(sample_content)]),
]
)
def test_retrying_proxy_swh_storage_content_add_metadata_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.content_add_metadata"
)
mock_memory.side_effect = StorageArgumentException(
"Refuse to add content_metadata!"
)
sample_content = sample_data["content_metadata"][0]
pk = sample_content["sha1"]
content_metadata = swh_storage.content_get_metadata([pk])
assert not content_metadata[pk]
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.content_add_metadata([sample_content])
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_skipped_content_add(swh_storage, sample_data):
"""Standard skipped_content_add works as before
"""
sample_content = sample_data["skipped_content"][0]
skipped_contents = list(swh_storage.skipped_content_missing([sample_content]))
assert len(skipped_contents) == 1
s = swh_storage.skipped_content_add([sample_content])
assert s == {
"skipped_content:add": 1,
}
skipped_content = list(swh_storage.skipped_content_missing([sample_content]))
assert len(skipped_content) == 0
def test_retrying_proxy_storage_skipped_content_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.skipped_content_add"
)
mock_memory.side_effect = [
# 1st & 2nd try goes ko
fake_hash_collision,
psycopg2.IntegrityError("skipped_content already inserted"),
# ok then!
{"skipped_content:add": 1},
]
sample_content = sample_data["skipped_content"][0]
s = swh_storage.skipped_content_add([sample_content])
assert s == {"skipped_content:add": 1}
mock_memory.assert_has_calls(
[
call([SkippedContent.from_dict(sample_content)]),
call([SkippedContent.from_dict(sample_content)]),
call([SkippedContent.from_dict(sample_content)]),
]
)
def test_retrying_proxy_swh_storage_skipped_content_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.skipped_content_add"
)
mock_memory.side_effect = StorageArgumentException(
"Refuse to add content_metadata!"
)
sample_content = sample_data["skipped_content"][0]
skipped_contents = list(swh_storage.skipped_content_missing([sample_content]))
assert len(skipped_contents) == 1
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.skipped_content_add([sample_content])
skipped_contents = list(swh_storage.skipped_content_missing([sample_content]))
assert len(skipped_contents) == 1
assert mock_memory.call_count == 1
def test_retrying_proxy_swh_storage_origin_add_one(swh_storage, sample_data):
"""Standard origin_add_one works as before
"""
sample_origin = sample_data["origin"][0]
origin = swh_storage.origin_get(sample_origin)
assert not origin
r = swh_storage.origin_add_one(sample_origin)
assert r == sample_origin["url"]
origin = swh_storage.origin_get(sample_origin)
assert origin["url"] == sample_origin["url"]
def test_retrying_proxy_swh_storage_origin_add_one_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
sample_origin = sample_data["origin"][1]
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.origin_add_one")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("origin already inserted"),
# ok then!
sample_origin["url"],
]
origin = swh_storage.origin_get(sample_origin)
assert not origin
r = swh_storage.origin_add_one(sample_origin)
assert r == sample_origin["url"]
mock_memory.assert_has_calls(
[
call(Origin.from_dict(sample_origin)),
call(Origin.from_dict(sample_origin)),
call(Origin.from_dict(sample_origin)),
]
)
def test_retrying_proxy_swh_storage_origin_add_one_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.origin_add_one")
mock_memory.side_effect = StorageArgumentException("Refuse to add origin always!")
sample_origin = sample_data["origin"][0]
origin = swh_storage.origin_get(sample_origin)
assert not origin
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.origin_add_one(sample_origin)
assert mock_memory.call_count == 1
def test_retrying_proxy_swh_storage_origin_visit_add(swh_storage, sample_data):
"""Standard origin_visit_add works as before
"""
sample_origin = sample_data["origin"][0]
origin_url = swh_storage.origin_add_one(sample_origin)
origin = list(swh_storage.origin_visit_get(origin_url))
assert not origin
origin_visit = swh_storage.origin_visit_add(origin_url, date_visit1, "hg")
assert origin_visit.origin == origin_url
assert isinstance(origin_visit.visit, int)
origin_visit = next(swh_storage.origin_visit_get(origin_url))
assert origin_visit["origin"] == origin_url
assert isinstance(origin_visit["visit"], int)
def test_retrying_proxy_swh_storage_origin_visit_add_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
sample_origin = sample_data["origin"][1]
origin_url = swh_storage.origin_add_one(sample_origin)
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.origin_visit_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("origin already inserted"),
# ok then!
{"origin": origin_url, "visit": 1},
]
origin = list(swh_storage.origin_visit_get(origin_url))
assert not origin
r = swh_storage.origin_visit_add(origin_url, date_visit1, "git")
assert r == {"origin": origin_url, "visit": 1}
mock_memory.assert_has_calls(
[
call(origin_url, date_visit1, "git"),
call(origin_url, date_visit1, "git"),
call(origin_url, date_visit1, "git"),
]
)
def test_retrying_proxy_swh_storage_origin_visit_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.origin_visit_add")
mock_memory.side_effect = StorageArgumentException("Refuse to add origin always!")
origin_url = sample_data["origin"][0]["url"]
origin = list(swh_storage.origin_visit_get(origin_url))
assert not origin
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.origin_visit_add(origin_url, date_visit1, "svn")
mock_memory.assert_has_calls(
[call(origin_url, date_visit1, "svn"),]
)
def test_retrying_proxy_storage_metadata_fetcher_add(swh_storage, sample_data):
"""Standard metadata_fetcher_add works as before
"""
fetcher = sample_data["fetcher"][0]
metadata_fetcher = swh_storage.metadata_fetcher_get(
fetcher["name"], fetcher["version"]
)
assert not metadata_fetcher
swh_storage.metadata_fetcher_add(**fetcher)
actual_fetcher = swh_storage.metadata_fetcher_get(
fetcher["name"], fetcher["version"]
)
assert actual_fetcher == fetcher
def test_retrying_proxy_storage_metadata_fetcher_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
fetcher = sample_data["fetcher"][0]
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.metadata_fetcher_add"
)
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("metadata_fetcher already inserted"),
# ok then!
[fetcher],
]
actual_fetcher = swh_storage.metadata_fetcher_get(
fetcher["name"], fetcher["version"]
)
assert not actual_fetcher
swh_storage.metadata_fetcher_add(**fetcher)
mock_memory.assert_has_calls(
[
call(fetcher["name"], fetcher["version"], fetcher["metadata"]),
call(fetcher["name"], fetcher["version"], fetcher["metadata"]),
call(fetcher["name"], fetcher["version"], fetcher["metadata"]),
]
)
def test_retrying_proxy_swh_storage_metadata_fetcher_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.metadata_fetcher_add"
)
mock_memory.side_effect = StorageArgumentException(
"Refuse to add metadata_fetcher always!"
)
fetcher = sample_data["fetcher"][0]
actual_fetcher = swh_storage.metadata_fetcher_get(
fetcher["name"], fetcher["version"]
)
assert not actual_fetcher
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.metadata_fetcher_add(**fetcher)
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_metadata_authority_add(swh_storage, sample_data):
"""Standard metadata_authority_add works as before
"""
authority = sample_data["authority"][0]
assert not swh_storage.metadata_authority_get(authority["type"], authority["url"])
swh_storage.metadata_authority_add(**authority)
actual_authority = swh_storage.metadata_authority_get(
authority["type"], authority["url"]
)
assert actual_authority == authority
def test_retrying_proxy_storage_metadata_authority_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
authority = sample_data["authority"][0]
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.metadata_authority_add"
)
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("foo bar"),
# ok then!
None,
]
assert not swh_storage.metadata_authority_get(authority["type"], authority["url"])
swh_storage.metadata_authority_add(**authority)
authority_arg_names = ("type", "url", "metadata")
authority_args = [authority[key] for key in authority_arg_names]
mock_memory.assert_has_calls(
[call(*authority_args), call(*authority_args), call(*authority_args),]
)
def test_retrying_proxy_swh_storage_metadata_authority_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.metadata_authority_add"
)
mock_memory.side_effect = StorageArgumentException(
"Refuse to add authority_id always!"
)
authority = sample_data["authority"][0]
swh_storage.metadata_authority_get(authority["type"], authority["url"])
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.metadata_authority_add(**authority)
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_origin_metadata_add(swh_storage, sample_data):
"""Standard origin_metadata_add works as before
"""
ori_meta = sample_data["origin_metadata"][0]
swh_storage.origin_add_one({"url": ori_meta["origin_url"]})
swh_storage.metadata_authority_add(**sample_data["authority"][0])
swh_storage.metadata_fetcher_add(**sample_data["fetcher"][0])
origin_metadata = swh_storage.origin_metadata_get(
ori_meta["origin_url"], ori_meta["authority"]
)
assert not origin_metadata
swh_storage.origin_metadata_add(**ori_meta)
origin_metadata = swh_storage.origin_metadata_get(
ori_meta["origin_url"], ori_meta["authority"]
)
assert origin_metadata
def test_retrying_proxy_storage_origin_metadata_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
ori_meta = sample_data["origin_metadata"][0]
swh_storage.origin_add_one({"url": ori_meta["origin_url"]})
swh_storage.metadata_authority_add(**sample_data["authority"][0])
swh_storage.metadata_fetcher_add(**sample_data["fetcher"][0])
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.origin_metadata_add"
)
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("foo bar"),
# ok then!
None,
]
# No exception raised as insertion finally came through
swh_storage.origin_metadata_add(**ori_meta)
mock_memory.assert_has_calls(
[ # 3 calls, as long as error raised
call(
ori_meta["origin_url"],
ori_meta["discovery_date"],
ori_meta["authority"],
ori_meta["fetcher"],
ori_meta["format"],
ori_meta["metadata"],
),
call(
ori_meta["origin_url"],
ori_meta["discovery_date"],
ori_meta["authority"],
ori_meta["fetcher"],
ori_meta["format"],
ori_meta["metadata"],
),
call(
ori_meta["origin_url"],
ori_meta["discovery_date"],
ori_meta["authority"],
ori_meta["fetcher"],
ori_meta["format"],
ori_meta["metadata"],
),
]
)
def test_retrying_proxy_swh_storage_origin_metadata_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.origin_metadata_add"
)
mock_memory.side_effect = StorageArgumentException("Refuse to add always!")
ori_meta = sample_data["origin_metadata"][0]
swh_storage.origin_add_one({"url": ori_meta["origin_url"]})
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.origin_metadata_add(**ori_meta)
assert mock_memory.call_count == 1
def test_retrying_proxy_swh_storage_origin_visit_update(swh_storage, sample_data):
"""Standard origin_visit_update works as before
"""
sample_origin = sample_data["origin"][0]
origin_url = swh_storage.origin_add_one(sample_origin)
origin_visit = swh_storage.origin_visit_add(origin_url, date_visit1, "hg")
ov = next(swh_storage.origin_visit_get(origin_url))
assert ov["origin"] == origin_url
assert ov["visit"] == origin_visit.visit
assert ov["status"] == "ongoing"
assert ov["snapshot"] is None
assert ov["metadata"] is None
swh_storage.origin_visit_update(origin_url, origin_visit.visit, status="full")
ov = next(swh_storage.origin_visit_get(origin_url))
assert ov["origin"] == origin_url
assert ov["visit"] == origin_visit.visit
assert ov["status"] == "full"
assert ov["snapshot"] is None
assert ov["metadata"] is None
def test_retrying_proxy_swh_storage_origin_visit_update_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
sample_origin = sample_data["origin"][1]
origin_url = sample_origin["url"]
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.origin_visit_update"
)
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("origin already inserted"),
# ok then!
{"origin": origin_url, "visit": 1},
]
visit_id = 1
swh_storage.origin_visit_update(origin_url, visit_id, status="full")
mock_memory.assert_has_calls(
[
call(origin_url, visit_id, metadata=None, snapshot=None, status="full"),
call(origin_url, visit_id, metadata=None, snapshot=None, status="full"),
call(origin_url, visit_id, metadata=None, snapshot=None, status="full"),
]
)
def test_retrying_proxy_swh_storage_origin_visit_update_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch(
"swh.storage.in_memory.InMemoryStorage.origin_visit_update"
)
mock_memory.side_effect = StorageArgumentException("Refuse to add origin always!")
origin_url = sample_data["origin"][0]["url"]
visit_id = 9
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.origin_visit_update(origin_url, visit_id, "partial")
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_directory_add(swh_storage, sample_data):
"""Standard directory_add works as before
"""
sample_dir = sample_data["directory"][0]
directory = swh_storage.directory_get_random() # no directory
assert not directory
s = swh_storage.directory_add([sample_dir])
assert s == {
"directory:add": 1,
}
directory_id = swh_storage.directory_get_random() # only 1
assert directory_id == sample_dir["id"]
def test_retrying_proxy_storage_directory_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.directory_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("directory already inserted"),
# ok then!
{"directory:add": 1},
]
sample_dir = sample_data["directory"][1]
directory_id = swh_storage.directory_get_random() # no directory
assert not directory_id
s = swh_storage.directory_add([sample_dir])
assert s == {
"directory:add": 1,
}
mock_memory.assert_has_calls(
[
call([Directory.from_dict(sample_dir)]),
call([Directory.from_dict(sample_dir)]),
call([Directory.from_dict(sample_dir)]),
]
)
def test_retrying_proxy_swh_storage_directory_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.directory_add")
mock_memory.side_effect = StorageArgumentException(
"Refuse to add directory always!"
)
sample_dir = sample_data["directory"][0]
directory_id = swh_storage.directory_get_random() # no directory
assert not directory_id
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.directory_add([sample_dir])
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_revision_add(swh_storage, sample_data):
"""Standard revision_add works as before
"""
sample_rev = sample_data["revision"][0]
revision = next(swh_storage.revision_get([sample_rev["id"]]))
assert not revision
s = swh_storage.revision_add([sample_rev])
assert s == {
"revision:add": 1,
}
revision = next(swh_storage.revision_get([sample_rev["id"]]))
assert revision["id"] == sample_rev["id"]
def test_retrying_proxy_storage_revision_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.revision_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("revision already inserted"),
# ok then!
{"revision:add": 1},
]
sample_rev = sample_data["revision"][0]
revision = next(swh_storage.revision_get([sample_rev["id"]]))
assert not revision
s = swh_storage.revision_add([sample_rev])
assert s == {
"revision:add": 1,
}
mock_memory.assert_has_calls(
[
call([Revision.from_dict(sample_rev)]),
call([Revision.from_dict(sample_rev)]),
call([Revision.from_dict(sample_rev)]),
]
)
def test_retrying_proxy_swh_storage_revision_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.revision_add")
mock_memory.side_effect = StorageArgumentException("Refuse to add revision always!")
sample_rev = sample_data["revision"][0]
revision = next(swh_storage.revision_get([sample_rev["id"]]))
assert not revision
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.revision_add([sample_rev])
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_release_add(swh_storage, sample_data):
"""Standard release_add works as before
"""
sample_rel = sample_data["release"][0]
release = next(swh_storage.release_get([sample_rel["id"]]))
assert not release
s = swh_storage.release_add([sample_rel])
assert s == {
"release:add": 1,
}
release = next(swh_storage.release_get([sample_rel["id"]]))
assert release["id"] == sample_rel["id"]
def test_retrying_proxy_storage_release_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.release_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("release already inserted"),
# ok then!
{"release:add": 1},
]
sample_rel = sample_data["release"][0]
release = next(swh_storage.release_get([sample_rel["id"]]))
assert not release
s = swh_storage.release_add([sample_rel])
assert s == {
"release:add": 1,
}
mock_memory.assert_has_calls(
[
call([Release.from_dict(sample_rel)]),
call([Release.from_dict(sample_rel)]),
call([Release.from_dict(sample_rel)]),
]
)
def test_retrying_proxy_swh_storage_release_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.release_add")
mock_memory.side_effect = StorageArgumentException("Refuse to add release always!")
sample_rel = sample_data["release"][0]
release = next(swh_storage.release_get([sample_rel["id"]]))
assert not release
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.release_add([sample_rel])
assert mock_memory.call_count == 1
def test_retrying_proxy_storage_snapshot_add(swh_storage, sample_data):
"""Standard snapshot_add works as before
"""
sample_snap = sample_data["snapshot"][0]
snapshot = swh_storage.snapshot_get(sample_snap["id"])
assert not snapshot
s = swh_storage.snapshot_add([sample_snap])
assert s == {
"snapshot:add": 1,
}
snapshot = swh_storage.snapshot_get(sample_snap["id"])
assert snapshot["id"] == sample_snap["id"]
def test_retrying_proxy_storage_snapshot_add_with_retry(
monkeypatch_sleep, swh_storage, sample_data, mocker, fake_hash_collision
):
"""Multiple retries for hash collision and psycopg2 error but finally ok
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.snapshot_add")
mock_memory.side_effect = [
# first try goes ko
fake_hash_collision,
# second try goes ko
psycopg2.IntegrityError("snapshot already inserted"),
# ok then!
{"snapshot:add": 1},
]
sample_snap = sample_data["snapshot"][0]
snapshot = swh_storage.snapshot_get(sample_snap["id"])
assert not snapshot
s = swh_storage.snapshot_add([sample_snap])
assert s == {
"snapshot:add": 1,
}
mock_memory.assert_has_calls(
[
call([Snapshot.from_dict(sample_snap)]),
call([Snapshot.from_dict(sample_snap)]),
call([Snapshot.from_dict(sample_snap)]),
]
)
def test_retrying_proxy_swh_storage_snapshot_add_failure(
swh_storage, sample_data, mocker
):
"""Unfiltered errors are raising without retry
"""
mock_memory = mocker.patch("swh.storage.in_memory.InMemoryStorage.snapshot_add")
mock_memory.side_effect = StorageArgumentException("Refuse to add snapshot always!")
sample_snap = sample_data["snapshot"][0]
snapshot = swh_storage.snapshot_get(sample_snap["id"])
assert not snapshot
with pytest.raises(StorageArgumentException, match="Refuse to add"):
swh_storage.snapshot_add([sample_snap])
assert mock_memory.call_count == 1