def test_can_update_repo():
controller = FakeController()
controller.insert_repository(
FileRepository(id="repo", product_versions=["a", "b", "c"]))
client = controller.client
# Should be able to get the repo.
repo = client.get_repository("repo").result()
# Let's try putting it back. Note we try changing both some mutable
# and immutable fields here.
update_f = client.update_repository(
attr.evolve(repo, eng_product_id=123, product_versions=["d", "b"]))
# The update should succeed (and return None)
assert update_f.result() is None
# Try getting the same repo back.
repo_updated = client.get_repository("repo").result()
# It should be equal to this:
assert repo_updated == FileRepository(
id="repo",
# product_versions is mutable, so it's what we asked for (with
# values canonicalized by sorting)
product_versions=["b", "d"],
# eng_product_id is not mutable, so that update was ignored
eng_product_id=None,
)
def load_initial(self):
"""Initial load of data into the fake, in the case where no state
has previously been persisted.
This will populate a hardcoded handful of repos which are expected
to always be present in a realistically configured rhsm-pulp server.
"""
self.ctrl.insert_repository(FileRepository(id="redhat-maintenance"))
self.ctrl.insert_repository(FileRepository(id="all-iso-content"))
self.ctrl.insert_repository(YumRepository(id="all-rpm-content"))
def get_task_instance(on, *repos):
iso_distributor = Distributor(
id="iso_distributor",
type_id="iso_distributor",
relative_url="root",
repo_id="redhat-maintenance",
)
maint_repo = FileRepository(id="redhat-maintenance",
distributors=[iso_distributor])
if on:
task_instance = FakeSetMaintenanceOn()
task_instance.pulp_client_controller.insert_repository(maint_repo)
else:
task_instance = FakeSetMaintenanceOff()
task_instance.pulp_client_controller.insert_repository(maint_repo)
# if unset maintenance mode, we need to pre-set maintenance first
report = task_instance.pulp_client.get_maintenance_report().result()
report = report.add([repo.id for repo in repos])
task_instance.pulp_client.set_maintenance(report)
for repo in list(repos):
task_instance.pulp_client_controller.insert_repository(repo)
return task_instance
def test_clear_file_skip_publish(command_tester):
"""Clearing a repo with file content while skipping publish succeeds."""
task_instance = FakeClearRepo()
repo = FileRepository(
id="some-filerepo",
eng_product_id=123,
relative_url="some/publish/url",
mutable_urls=[],
)
files = [FileUnit(path="hello.txt", size=123, sha256sum="a" * 64)]
task_instance.pulp_client_controller.insert_repository(repo)
task_instance.pulp_client_controller.insert_units(repo, files)
# It should run with expected output.
command_tester.test(
task_instance.main,
[
"test-clear-repo",
"--pulp-url",
"https://pulp.example.com/",
"--skip",
"foo,publish,bar",
"some-filerepo",
],
)
# It should not have published Pulp repos
assert task_instance.pulp_client_controller.publish_history == []
def test_can_upload_history(tmpdir):
"""repo.upload_file() succeeds with fake client and populates upload_history.
Note that upload_history is deprecated, but remains working for now.
"""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
upload_f = repo1.upload_file(str(somefile))
# The future should resolve successfully
tasks = upload_f.result()
# The task should be successful.
assert tasks[0].succeeded
# The change should be reflected in the controller's upload history
history = controller.upload_history
digest = "fad3fc1e6d583b2003ec0a5273702ed8fcc2504271c87c40d9176467ebe218cb"
assert len(history) == 1
assert history[0].repository == repo1
assert history[0].tasks == tasks
assert history[0].name == somefile.basename
assert history[0].sha256 == digest
def test_client_no_cache_errors(monkeypatch):
"""caching_pulp_client does not cache failed get_repository calls"""
with TaskWithPulpClient() as task:
monkeypatch.setattr(
sys,
"argv",
[
"",
"--pulp-url",
"http://some.url",
],
)
# Try getting a repo *before* it's added to the client.
repo1 = task.caching_pulp_client.get_repository("test-repo")
# Now add the repo and get it again.
task.pulp_ctrl.insert_repository(FileRepository(id="test-repo"))
repo2 = task.caching_pulp_client.get_repository("test-repo")
repo3 = task.caching_pulp_client.get_repository("test-repo")
# The first fetch should fail since the repo didn't exist yet.
assert repo1.exception()
# Since it failed, it should not have been cached and returned again.
assert repo1 is not repo2
# But caching worked as usual for the next two calls.
assert repo2 is repo3
# And those calls succeeded.
assert repo2.result().id == "test-repo"
def test_client_caches(monkeypatch):
"""caching_pulp_client caches the result of calls to get_repository"""
with TaskWithPulpClient() as task:
monkeypatch.setattr(
sys,
"argv",
[
"",
"--pulp-url",
"http://some.url",
],
)
# Add some repo
task.pulp_ctrl.insert_repository(FileRepository(id="test-repo"))
# Let's try getting it via the caching client.
with task.caching_pulp_client as client:
repo1 = task.caching_pulp_client.get_repository("test-repo")
repo2 = task.caching_pulp_client.get_repository("test-repo")
# Due to the caching, it should give me back *exactly* the same
# object in both cases.
assert repo1 is repo2
# And it should fetch OK
assert repo1.result().id == "test-repo"
def test_upload_checks_repos(tmpdir):
"""Upload fails if upload apparently succeeded in pulp client, yet the item
still is missing from all Pulp repos."""
testfile = tmpdir.join("myfile")
testfile.write("hello")
pulp_ctrl = FakeController()
repo = FileRepository(id="some-repo")
pulp_ctrl.insert_repository(repo)
item = NeverInReposItem(pushsource_item=FilePushItem(
name="test", src=str(testfile), dest=["some-repo"]))
item = item.with_checksums()
ctx = item.upload_context(pulp_ctrl.client)
upload_f = item.ensure_uploaded(ctx)
# The upload attempt should fail.
exc = upload_f.exception()
# It should tell us why & which item.
assert (
"item supposedly uploaded successfully, but remains missing from Pulp:"
in str(exc))
assert "FilePushItem(name='test'" in str(exc)
def test_can_update_repo(requests_mocker, client):
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/repositories/my-repo/",
text="null",
headers={"Content-Type": "application/json"},
)
repo = FileRepository(
id="my-repo", eng_product_id=123, product_versions=["1.0", "1.1"]
)
update_f = client.update_repository(repo)
# It should succeed.
update_f.result()
# It should have done a single request.
assert len(requests_mocker.request_history) == 1
req = requests_mocker.request_history[0]
# Should have been a PUT to the appropriate API.
assert req.method == "PUT"
assert req.url == "https://pulp.example.com/pulp/api/v2/repositories/my-repo/"
# Should have requested exactly this update - only the mutable notes
assert req.json() == {
"delta": {
"notes": {
# Note the serialization into embedded JSON here.
"product_versions": '["1.0","1.1"]'
}
}
}
def test_can_reupload_file_meta(tmpdir):
"""Can overwrite by uploading same content twice with different metadata."""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
time1 = datetime.datetime(2021, 12, 14, 14, 44, 0)
time2 = datetime.datetime(2022, 1, 2, 3, 4, 5)
upload_f = repo1.upload_file(
str(somefile),
description="My great file",
cdn_path="/foo/bar.txt",
cdn_published=time1,
)
# The future should resolve successfully
tasks = upload_f.result()
# The task should be successful.
assert tasks[0].succeeded
# Now upload again, but with some different values.
upload_f = repo1.upload_file(str(somefile),
description="My even better file",
cdn_published=time2)
# The future should resolve successfully
tasks = upload_f.result()
# The task should be successful.
assert tasks[0].succeeded
# File should now be in repo.
units_in_repo = list(repo1.search_content())
# Should result in just one unit, as the second upload effectively merges
# with the existing unit.
assert len(units_in_repo) == 1
unit = units_in_repo[0]
# Sanity check we got the right thing.
assert unit.path == "some-file.txt"
# Extra fields should be equal to the values passed in at the most
# recent upload.
assert unit.description == "My even better file"
assert unit.cdn_published == time2
# cdn_path was provided at the first upload and not the second.
# In such cases it is expected that the field is wiped out, as you must
# always provide *all* metadata at once.
assert unit.cdn_path is None
def fake_controller(fake_state_path):
"""Yields a pulplib FakeController which has been pre-populated with
repos used by staged-mixed.
"""
fake = PersistentFake(state_path=fake_state_path)
fake.load_initial()
controller = fake.ctrl
# Add the repositories which are referenced from the staging area.
controller.insert_repository(FileRepository(id="iso-dest1"))
controller.insert_repository(
FileRepository(id="iso-dest2", arch="x86_64", eng_product_id=123))
controller.insert_repository(
YumRepository(id="dest1", arch="x86_64", eng_product_id=123))
controller.insert_repository(YumRepository(id="dest2"))
yield controller
def test_update_missing_repo():
controller = FakeController()
client = controller.client
# Try to update something which is previously unknown to the client.
update_f = client.update_repository(FileRepository(id="whatever"))
# It should fail telling us the repo doesn't exist
assert "repository not found: whatever" in str(update_f.exception())
def test_upload_file_contains_unicode(client, requests_mocker):
file_obj = StringIO("哈罗")
upload_id = "cfb1fed0-752b-439e-aa68-fba68eababa3"
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/content/uploads/%s/0/" % upload_id,
json=[],
)
repo_id = "repo1"
repo = FileRepository(id=repo_id)
repo.__dict__["_client"] = client
upload_f = client._do_upload_file(upload_id, file_obj)
assert upload_f.result() == (
"478f4808df7898528c7f13dc840aa321c4109f5c9f33bad7afcffc0253d4ff8f",
6,
)
def test_can_upload_units(tmpdir):
"""repo.upload_file() succeeds with fake client and populates units."""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
otherfile = tmpdir.join("another.txt")
otherfile.write("ahoy there")
upload1_f = repo1.upload_file(str(somefile))
upload2_f = repo1.upload_file(str(otherfile),
relative_url="another/path.txt")
for f in [upload1_f, upload2_f]:
# The future should resolve successfully
tasks = f.result()
# The task should be successful.
assert tasks[0].succeeded
# If I now search for content in that repo, or content across all repos...
units_in_repo = sorted(repo1.search_content().result(),
key=lambda u: u.sha256sum)
units_all = sorted(client.search_content().result(),
key=lambda u: u.sha256sum)
# They should be equal
assert units_all == units_in_repo
# And they should be this
assert units_in_repo == [
FileUnit(
path="another/path.txt",
size=10,
sha256sum=
"94c0c9d847ecaa45df01999676db772e5cb69cc54e1ff9db31d02385c56a86e1",
repository_memberships=["repo1"],
unit_id="d4713d60-c8a7-0639-eb11-67b367a9c378",
),
FileUnit(
path="some-file.txt",
size=29,
sha256sum=
"fad3fc1e6d583b2003ec0a5273702ed8fcc2504271c87c40d9176467ebe218cb",
repository_memberships=["repo1"],
unit_id="e3e70682-c209-4cac-629f-6fbed82c07cd",
),
]
def test_update_checks_state():
"""Update fails if update apparently succeeded in pulp client, yet the item
doesn't match the desired state."""
pulp_unit = FileUnit(
unit_id="some-file-unit",
path="some/file.txt",
size=5,
sha256sum=
"49ae93732fcf8d63fe1cce759664982dbd5b23161f007dba8561862adc96d063",
description="a test file",
repository_memberships=["some-repo"],
)
pulp_ctrl = FakeController()
repo = FileRepository(id="some-repo")
pulp_ctrl.insert_repository(repo)
pulp_ctrl.insert_units(repo, [pulp_unit])
item = NeverUpToDateItem(
pushsource_item=FilePushItem(
name="some/file.txt",
sha256sum=
"49ae93732fcf8d63fe1cce759664982dbd5b23161f007dba8561862adc96d063",
dest=["some-repo"],
),
pulp_unit=pulp_unit,
pulp_state=State.NEEDS_UPDATE,
)
# Try updating it.
update_f = item.ensure_uptodate(pulp_ctrl.client)
# The update attempt should fail.
exc = update_f.exception()
# It should tell us why.
assert (
"item supposedly updated successfully, but actual and desired state still differ:"
in str(exc))
# It should tell us the item we failed to process.
assert "item: FilePushItem(name='some/file.txt'" in str(exc)
# It should show the current and desired field values:
# The 'current unit', i.e. the state after we updated, reversed the original
# description.
assert re.search(r"current unit: FileUnit.*elif tset a", str(exc))
# The 'desired unit', i.e. the reason we still don't consider the unit up-to-date,
# wants to reverse the description back again...
assert re.search(r"desired unit: FileUnit.*a test file", str(exc))
def test_get_relative_url_with_file_object(tmpdir):
repo = FileRepository(id="some-repo")
file_obj = StringIO()
with pytest.raises(ValueError):
repo._get_relative_url(file_obj, None)
with pytest.raises(ValueError):
repo._get_relative_url(file_obj, "some/path/")
assert repo._get_relative_url(file_obj, "path/foo.txt") == "path/foo.txt"
def test_update_repo_fails(requests_mocker, client):
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/repositories/my-repo/", status_code=400
)
repo = FileRepository(
id="my-repo", eng_product_id=123, product_versions=["1.0", "1.1"]
)
update_f = client.update_repository(repo)
# It should fail, since the HTTP request failed.
assert "400 Client Error" in str(update_f.exception())
def test_replace_file(tmpdir):
"""repo.upload_file() behaves as expected when replacing a file of the same name."""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
otherfile = tmpdir.join("another.txt")
otherfile.write("ahoy there")
# Upload both files, using the same relative_url for each.
repo1.upload_file(str(somefile), relative_url="darmok-jalad.txt").result()
repo1.upload_file(str(otherfile), relative_url="darmok-jalad.txt").result()
# If I now search for content in that repo, or content across all repos...
units_in_repo = sorted(repo1.search_content().result(),
key=lambda u: u.sha256sum)
units_all = sorted(client.search_content().result(),
key=lambda u: u.sha256sum)
# I should find that only the second uploaded file is still present in the repo.
assert units_in_repo == [
FileUnit(
path="darmok-jalad.txt",
size=10,
sha256sum=
"94c0c9d847ecaa45df01999676db772e5cb69cc54e1ff9db31d02385c56a86e1",
repository_memberships=["repo1"],
unit_id="d4713d60-c8a7-0639-eb11-67b367a9c378",
)
]
# However, both units should still exist in the system; the first uploaded unit
# has become an orphan.
assert units_all == units_in_repo + [
FileUnit(
path="darmok-jalad.txt",
size=29,
sha256sum=
"fad3fc1e6d583b2003ec0a5273702ed8fcc2504271c87c40d9176467ebe218cb",
content_type_id="iso",
repository_memberships=[],
unit_id="e3e70682-c209-4cac-629f-6fbed82c07cd",
)
]
def test_upload_file_verylarge(client, requests_mocker):
"""Client can upload a 2GB file successfully."""
file_size = 2000000000
file_obj = ZeroesIO(file_size)
upload_id = "cfb1fed0-752b-439e-aa68-fba68eababa3"
# We will be uploading many chunks and we need to mock the 'offset' for each one...
# Note this must align with the client's internal CHUNK_SIZE.
chunk_size = 1024 * 1024
for i in range(0, 3000):
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/content/uploads/%s/%d/"
% (upload_id, i * chunk_size),
json=[],
)
repo_id = "repo1"
repo = FileRepository(id=repo_id)
repo.__dict__["_client"] = client
# It should be able to upload successfully.
upload_f = client._do_upload_file(upload_id, file_obj)
assert upload_f.result() == (
# We should get the right checksum and size back, which proves all
# the data was read correctly.
#
# If you want to verify this checksum, try:
#
# dd if=/dev/zero bs=1000000 count=2000 status=none | sha256sum
#
"2e0c654b6cba3a1e816726bae0eac481eb7fd0351633768c3c18392e0f02b619",
file_size,
)
def test_no_implemented(command_tester):
task_instance = SetMaintenance()
controller = FakeController()
controller.insert_repository(FileRepository(id="redhat-maintenance"))
client = controller.client
arg = [
"test-maintenance", "--pulp-url", "http://some.url", "--repo-ids",
"repo1"
]
with patch("pubtools._pulp.services.PulpClientService.pulp_client",
client):
with pytest.raises(NotImplementedError):
with patch("sys.argv", arg):
task_instance.main()
def test_upload_nonexistent_file_raises():
"""repo.upload_file() with nonexistent file fails with fake client"""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1")
# If file's not found, Python 2 raises IOError and Python 3 raises
# FileNotFoundError. The latter one is not defined in Python 2.
if sys.version_info < (3, ):
exception = IOError
else:
exception = FileNotFoundError
with pytest.raises(exception):
upload_f = repo1.upload_file("nonexistent_file").result()
def test_clear_empty_repo(command_tester, fake_collector):
"""Clearing a repo which is already empty succeeds."""
task_instance = FakeClearRepo()
repo = FileRepository(id="some-filerepo")
task_instance.pulp_client_controller.insert_repository(repo)
command_tester.test(
task_instance.main,
[
"test-clear-repo", "--pulp-url", "https://pulp.example.com/",
"some-filerepo"
],
)
# No push items recorded
assert not fake_collector.items
def test_upload_file_meta_wrong_fields(tmpdir):
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
# This should immediately give an error
with pytest.raises(ValueError) as excinfo:
repo1.upload_file(str(somefile),
description="My great file",
size=48,
other="whatever")
# It should give an indication of the problem
assert "Not mutable FileUnit field(s): other, size" in str(excinfo.value)
def test_upload_repo_absent_raises(tmpdir):
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1")
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
repo_copy1 = client.get_repository("repo1")
repo_copy2 = client.get_repository("repo1")
# if repo's deleted
assert repo_copy1.delete().result()
exception = repo_copy2.upload_file(str(somefile)).exception()
assert isinstance(exception, PulpException)
assert "repo1 not found" in str(exception)
def test_set_maintenance():
controller = FakeController()
maintain_repo = FileRepository(id="redhat-maintenance")
controller.insert_repository(maintain_repo)
# now the maintenance repo is empty
client = controller.client
report = client.get_maintenance_report().result()
assert isinstance(report, MaintenanceReport)
# return an empty report
assert report.entries == []
# there's no entries in the report
report = report.add(repo_ids=["repo1", "repo2"])
client.set_maintenance(report).result()
# add entries to report and set maintenance
# upload_file and publish should be called once each
assert len(controller.upload_history) == 1
assert len(controller.publish_history) == 1
# get_maintenance_report should give a report object
report = client.get_maintenance_report().result()
assert report.last_updated_by == "ContentDelivery"
assert len(report.entries) == 2
report = report.remove(repo_ids=["repo1"], owner="jazhang@hostname")
client.set_maintenance(report).result()
# the report in repo should have updated
report = client.get_maintenance_report().result()
assert report.last_updated_by == "jazhang@hostname"
assert len(report.entries) == 1
assert report.entries[0].repo_id == "repo2"
def test_update_invalidates(monkeypatch):
"""update_repository should invalidate the cache for that repository"""
with TaskWithPulpClient() as task:
monkeypatch.setattr(
sys,
"argv",
[
"",
"--pulp-url",
"http://some.url",
],
)
# Add some repo
task.pulp_ctrl.insert_repository(
FileRepository(id="test-repo", product_versions=["a", "b"])
)
# Let's try getting it via the caching client.
repo1 = task.caching_pulp_client.get_repository("test-repo").result()
repo2 = task.caching_pulp_client.get_repository("test-repo").result()
# Initially consistent
assert repo1.product_versions == ["a", "b"]
assert repo2.product_versions == ["a", "b"]
# Let's update the repo
task.caching_pulp_client.update_repository(
attr.evolve(repo1, product_versions=["new", "versions"])
).result()
# Let's get the repo again...
repo3 = task.caching_pulp_client.get_repository("test-repo")
# The cache should have been smart enough to realize it can't
# return the old cached value since the repo was updated.
assert repo3.product_versions == ["new", "versions"]
def test_upload_file_verylarge():
"""Fake client can upload a 2GB file successfully."""
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
file_size = 2000000000
file_obj = ZeroesIO(file_size)
upload_f = repo1.upload_file(file_obj, relative_url="big-file")
# The future should resolve successfully
tasks = upload_f.result()
# The task should be successful.
assert tasks[0].succeeded
# I should be able to find the corresponding unit.
units_all = sorted(client.search_content().result(),
key=lambda u: u.sha256sum)
assert units_all == [
FileUnit(
path="big-file",
size=2000000000,
# If you want to verify this checksum, try:
#
# dd if=/dev/zero bs=1000000 count=2000 status=none | sha256sum
#
sha256sum=
"2e0c654b6cba3a1e816726bae0eac481eb7fd0351633768c3c18392e0f02b619",
repository_memberships=["repo1"],
unit_id="e3e70682-c209-4cac-629f-6fbed82c07cd",
)
]
def test_can_upload_file_meta(tmpdir):
controller = FakeController()
controller.insert_repository(FileRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
upload_f = repo1.upload_file(
str(somefile),
description="My great file",
cdn_path="/foo/bar.txt",
version="2.0",
)
# The future should resolve successfully
tasks = upload_f.result()
# The task should be successful.
assert tasks[0].succeeded
# File should now be in repo.
units_in_repo = list(repo1.search_content())
assert len(units_in_repo) == 1
unit = units_in_repo[0]
# Sanity check we got the right thing.
assert unit.path == "some-file.txt"
# Extra fields we passed during upload should be present here.
assert unit.description == "My great file"
assert unit.cdn_path == "/foo/bar.txt"
assert unit.version == "2.0"
def test_upload_file(client, requests_mocker, tmpdir, caplog):
"""test upload a file to a repo in pulp"""
logging.getLogger().setLevel(logging.INFO)
caplog.set_level(logging.INFO)
repo_id = "repo1"
repo = FileRepository(id=repo_id)
repo.__dict__["_client"] = client
client._CHUNK_SIZE = 20
request_body = {
"_href":
"/pulp/api/v2/content/uploads/cfb1fed0-752b-439e-aa68-fba68eababa3/",
"upload_id": "cfb1fed0-752b-439e-aa68-fba68eababa3",
}
upload_id = request_body["upload_id"]
import_report = {
"result": {},
"error": {},
"spawned_tasks": [{
"_href": "/pulp/api/v2/tasks/task1/",
"task_id": "task1"
}],
}
tasks_report = [{"task_id": "task1", "state": "finished"}]
somefile = tmpdir.join("some-file.txt")
somefile.write(b"there is some binary data:\x00\x01\x02")
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/content/uploads/",
json=request_body)
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/content/uploads/%s/0/" %
upload_id,
json=[],
)
requests_mocker.put(
"https://pulp.example.com/pulp/api/v2/content/uploads/%s/20/" %
upload_id,
json=[],
)
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/%s/actions/import_upload/"
% repo_id,
json=import_report,
)
requests_mocker.post("https://pulp.example.com/pulp/api/v2/tasks/search/",
json=tasks_report)
requests_mocker.delete(
"https://pulp.example.com/pulp/api/v2/content/uploads/%s/" % upload_id,
json=[])
assert repo.upload_file(str(somefile)).result() == [
Task(id="task1", succeeded=True, completed=True)
]
# the 6th request call might not be done in time, try 1000
# times with .01 sec sleep before next try.
for i in range(1000):
time.sleep(0.01)
try:
assert requests_mocker.call_count == 6
except AssertionError:
if i != 999:
continue
else:
raise
else:
break
# 4th call should be import, check if right unit_key's passed
import_request = requests_mocker.request_history[3].json()
import_unit_key = {
u"name": somefile.basename,
u"checksum":
u"fad3fc1e6d583b2003ec0a5273702ed8fcc2504271c87c40d9176467ebe218cb",
u"size": 29,
}
assert import_request["unit_key"] == import_unit_key
messages = caplog.messages
# It should tell us about the upload
assert (
"Uploading some-file.txt to repo1 [cfb1fed0-752b-439e-aa68-fba68eababa3]"
in messages)
# task's spawned and completed
assert "Created Pulp task: task1" in messages
assert "Pulp task completed: task1" in messages
def test_upload_detached():
"""upload_file raises if called on a detached repo"""
with pytest.raises(DetachedException):
FileRepository(id="some-repo").upload_file("some-file")
