def test_search_srpms(pulp):
"""Test convenient method for searching srpms"""
repo = YumRepository(id="test_repo_1", )
repo.__dict__["_client"] = pulp.client
unit_1 = RpmUnit(
name="test",
version="1.0",
release="1",
arch="src",
filename="test.src.rpm",
content_type_id="srpm",
)
unit_2 = RpmUnit(
name="test-devel",
version="1.0",
release="1",
arch="src",
filename="test-devel.src.rpm",
content_type_id="srpm",
)
pulp.insert_repository(repo)
pulp.insert_units(repo, [unit_1, unit_2])
matcher = Matcher(None, None)
criteria = matcher._create_or_criteria(["filename"], [("test.src.rpm", )])
# let Future return result
result = matcher.search_srpms(criteria, [repo]).result()
# there should be be only one unit in the result set according to criteria
assert len(result) == 1
assert result.pop().filename == "test.src.rpm"
def test_publish_retries(fast_poller, requests_mocker, client, caplog):
"""publish retries distributors as they fail"""
caplog.set_level(logging.WARNING)
repo = YumRepository(
id="some-repo",
distributors=(
Distributor(id="yum_distributor", type_id="yum_distributor"),
Distributor(id="cdn_distributor", type_id="cdn_distributor"),
),
)
repo.__dict__["_client"] = client
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/some-repo/actions/publish/",
[
{"json": {"spawned_tasks": [{"task_id": "task1"}]}},
{"json": {"spawned_tasks": [{"task_id": "task2"}]}},
{"json": {"spawned_tasks": [{"task_id": "task3"}]}},
],
)
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/tasks/search/",
[
{"json": [{"task_id": "task1", "state": "finished"}]},
{"json": [{"task_id": "task2", "state": "error"}]},
{"json": [{"task_id": "task3", "state": "finished"}]},
],
)
publish_f = repo.publish()
# It should succeed
tasks = publish_f.result()
# It should return only the *successful* tasks
assert sorted([t.id for t in tasks]) == ["task1", "task3"]
# Pick out the HTTP requests triggering distributors
publish_reqs = [
req
for req in requests_mocker.request_history
if req.url
== "https://pulp.example.com/pulp/api/v2/repositories/some-repo/actions/publish/"
]
publish_distributors = [req.json()["id"] for req in publish_reqs]
# It should have triggered cdn_distributor twice, since the first attempt failed
assert publish_distributors == [
"yum_distributor",
"cdn_distributor",
"cdn_distributor",
]
# The retry should have been logged
messages = caplog.messages
assert (
messages[-1].splitlines()[0] == "Retrying due to error: Task task2 failed [1/6]"
)
def test_publish_fail(fast_poller, requests_mocker, client):
"""publish raises TaskFailedException if publish task fails"""
repo = YumRepository(
id="some-repo",
distributors=(Distributor(id="yum_distributor",
type_id="yum_distributor"), ),
)
repo.__dict__["_client"] = client
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/some-repo/actions/publish/",
json={"spawned_tasks": [{
"task_id": "task1"
}]},
)
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/tasks/search/",
json=[{
"task_id": "task1",
"state": "error"
}],
)
publish_f = repo.publish()
# It should raise this exception
with pytest.raises(TaskFailedException) as error:
publish_f.result()
# The exception should have a reference to the task which failed
assert error.value.task.id == "task1"
assert "Task task1 failed" in str(error.value)
def test_can_publish():
"""repo.publish() succeeds with fake client and populates publish_history."""
controller = FakeController()
controller.insert_repository(
YumRepository(
id="repo1",
distributors=[
Distributor(id="yum_distributor", type_id="yum_distributor"),
Distributor(id="cdn_distributor",
type_id="rpm_rsync_distributor"),
],
))
controller.insert_repository(YumRepository(id="repo2"))
client = controller.client
repo1 = client.get_repository("repo1")
# Call to publish should succeed
publish_f = repo1.publish()
# The future should resolve successfully
tasks = publish_f.result()
# It should have returned at least one successful task.
assert tasks
for task in tasks:
assert task.succeeded
# The change should be reflected in the controller's publish history
history = controller.publish_history
assert len(history) == 1
assert history[0].repository.id == "repo1"
assert history[0].tasks == tasks
def test_get_population_sources():
repo = YumRepository(
id="rhel-8-for-x86_64-appstream-rpms",
content_set="rhel-8-for-x86_64-appstream-rpms",
population_sources=["src_1", "src_2"],
)
fake_ubipopulate = FakeUbiPopulate(
"foo.pulp.com", ("foo", "foo"), False, ubiconfig_dir_or_url=TEST_DATA_DIR
)
fake_pulp = fake_ubipopulate.pulp_client_controller
repo_1 = YumRepository(
id="src_1",
content_set="src_1_cs",
)
repo_2 = YumRepository(
id="src_2",
content_set="src_2_cs",
)
fake_pulp.insert_repository(repo_1)
fake_pulp.insert_repository(repo_2)
repos = fake_ubipopulate._get_population_sources(
repo
) # pylint: disable=protected-access
assert len(repos) == 2
assert ["src_1", "src_2"] == sorted([repo.id for repo in repos])
def test_can_sync():
"""repo.sync() succeeds with fake client and populates sync_history."""
controller = FakeController()
controller.insert_repository(YumRepository(id="repo1"))
controller.insert_repository(YumRepository(id="repo2"))
client = controller.client
repo1 = client.get_repository("repo1")
# Call to sync should succeed
sync_f = repo1.sync(YumSyncOptions(feed="mock://feed/"))
# The future should resolve successfully
tasks = sync_f.result()
# It should have returned at least one successful task.
assert tasks
for task in tasks:
assert task.succeeded
# The change should be reflected in the controller's sync history
history = controller.sync_history
assert len(history) == 1
assert history[0].repository.id == "repo1"
assert history[0].tasks == tasks
def test_publish_out_repos(mock_ubipop_runner):
dt = datetime(2019, 9, 12, 0, 0, 0)
d1 = Distributor(
id="yum_distributor",
type_id="yum_distributor",
repo_id="repo",
last_publish=dt,
relative_url="content/unit/2/client",
)
repo = YumRepository(
id="repo",
eng_product_id=102,
distributors=[d1],
relative_url="content/unit/2/client",
)
fake_pulp = FakeController()
repo.__dict__["_client"] = fake_pulp.client
fake_pulp.insert_repository(repo)
# Setup output repos, leave only binary repo as the actual one
mock_ubipop_runner.repos.out_repos = RepoSet(
f_proxy(f_return(repo)), f_proxy(f_return()), f_proxy(f_return())
)
fts = mock_ubipop_runner._publish_out_repos()
# we should publish only one repository with one distributor
assert len(fts) == 1
assert [hist.repository.id for hist in fake_pulp.publish_history] == ["repo"]
def test_search_units(pulp):
"""Test simple search for units"""
repo = YumRepository(id="test_repo", )
repo.__dict__["_client"] = pulp.client
unit_1 = RpmUnit(name="test", version="1.0", release="1", arch="x86_64")
unit_2 = RpmUnit(name="test", version="1.0", release="1", arch="i386")
pulp.insert_repository(repo)
pulp.insert_units(repo, [unit_1, unit_2])
matcher = Matcher(None, None)
criteria = matcher._create_or_criteria(["name", "arch"],
[("test", "x86_64")])
# let Future return result
search_result = matcher._search_units(repo, criteria, "rpm").result()
# result should be set
assert isinstance(search_result, set)
# with only 1 item
assert len(search_result) == 1
unit = search_result.pop()
# unit should be UbiUnit
assert isinstance(unit, UbiUnit)
# internally _unit attr should be RpmUnit
assert isinstance(unit._unit, RpmUnit)
# unit has name "test"
assert unit.name == "test"
# and proper associate_source_repo_id set
assert unit.associate_source_repo_id == "test_repo"
def test_search_moludemds(pulp):
"""Test convenient method for searching modulemds"""
repo = YumRepository(id="test_repo_1", )
repo.__dict__["_client"] = pulp.client
unit_1 = ModulemdUnit(
name="test",
stream="10",
version=100,
context="abcdef",
arch="x86_64",
)
unit_2 = ModulemdUnit(
name="test",
stream="20",
version=100,
context="abcdef",
arch="x86_64",
)
pulp.insert_repository(repo)
pulp.insert_units(repo, [unit_1, unit_2])
matcher = Matcher(None, None)
criteria = matcher._create_or_criteria(["name", "stream"],
[("test", "10")])
# let Future return result
result = matcher.search_modulemds(criteria, [repo]).result()
# there should be be only one unit in the result set according to criteria
assert len(result) == 1
assert result.pop().nsvca == "test:10:100:abcdef:x86_64"
def test_copy_content_empty_repo(controller):
"""copy_content from empty repo succeeds and copies nothing"""
src = YumRepository(id="empty-repo")
dest = YumRepository(id="dest-repo")
controller.insert_repository(src)
controller.insert_repository(dest)
client = controller.client
# Repos are initially detached, re-fetch them via client
src = client.get_repository(src.id).result()
dest = client.get_repository(dest.id).result()
# It should succeed
copy_tasks = list(client.copy_content(src, dest))
# It should have at least one task
assert copy_tasks
for t in copy_tasks:
# Every task should have succeeded
assert t.succeeded
# No units should have been copied
assert not t.units
def test_publish_cancel(fast_poller, requests_mocker, client, caplog):
"""Cancelling a publish future will cancel running Pulp task(s)."""
repo = YumRepository(
id="some-repo",
distributors=(
Distributor(id="yum_distributor", type_id="yum_distributor"),
Distributor(id="cdn_distributor", type_id="cdn_distributor"),
),
)
repo.__dict__["_client"] = client
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/some-repo/actions/publish/",
[{
"json": {
"spawned_tasks": [{
"task_id": "task1"
}]
}
}],
)
task_search_url = "https://pulp.example.com/pulp/api/v2/tasks/search/"
requests_mocker.post(task_search_url, [{
"json": [{
"task_id": "task1",
"state": "running"
}]
}])
requests_mocker.delete("https://pulp.example.com/pulp/api/v2/tasks/task1/")
# Start the publish
publish_f = repo.publish()
# Wait until we're sure poll thread has seen this task
for _ in range(0, 1000):
if (requests_mocker.last_request
and requests_mocker.last_request.url == task_search_url):
break
time.sleep(0.001)
assert requests_mocker.last_request.url == task_search_url
# We should be able to cancel it
assert publish_f.cancel()
# It should have cancelled the underlying Pulp task
task_req = [
r for r in requests_mocker.request_history
if r.url == "https://pulp.example.com/pulp/api/v2/tasks/task1/"
]
assert len(task_req) == 1
assert task_req[0].method == "DELETE"
def test_related_repositories_not_found(client, requests_mocker):
"""test Repository.get_*_repository returns Future[None] if repository is not found"""
repo_binary_test = YumRepository(id="repo_binary", relative_url="some/repo/os")
repo_binary_test.__dict__["_client"] = client
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/search/", json=[]
)
repo = repo_binary_test.get_source_repository()
assert repo.result() is None
def test_upload_empty_comps_xml(client, requests_mocker):
"""A client can upload an empty comps.xml, which merely removes existing units."""
repo_id = "repo1"
repo = YumRepository(id=repo_id)
repo.__dict__["_client"] = client
xml = BytesIO(b"<comps/>")
# Set up the requests it'll do:
#
# It should unassociate previous units
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/repo1/actions/unassociate/",
json={"spawned_tasks": [{
"task_id": "remove-task"
}]},
)
# It'll search for the status of tasks.
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/tasks/search/",
json=[{
"task_id": "remove-task",
"state": "finished"
}],
)
# And... that's it.
# It should start the upload OK
upload_f = repo.upload_comps_xml(xml)
# I can await the result
tasks = upload_f.result()
# It should just return the removal task
assert [t.id for t in tasks] == ["remove-task"]
assert tasks[0].completed
assert tasks[0].succeeded
# Check exactly the removed types
assert requests_mocker.request_history[0].json() == {
"criteria": {
"type_ids": [
"package_group",
"package_category",
"package_environment",
"package_langpacks",
]
}
}
def test_publish_with_options(requests_mocker, client):
"""publish passes expected config into distributors based on publish options"""
repo = YumRepository(
id="some-repo",
distributors=(
Distributor(id="yum_distributor", type_id="yum_distributor"),
Distributor(id="cdn_distributor", type_id="rpm_rsync_distributor"),
),
)
repo.__dict__["_client"] = client
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/repositories/some-repo/actions/publish/",
[
{"json": {"spawned_tasks": [{"task_id": "task1"}]}},
{"json": {"spawned_tasks": [{"task_id": "task2"}]}},
],
)
requests_mocker.post(
"https://pulp.example.com/pulp/api/v2/tasks/search/",
[
{"json": [{"task_id": "task1", "state": "finished"}]},
{"json": [{"task_id": "task2", "state": "finished"}]},
],
)
options = PublishOptions(
clean=True, force=True, origin_only=True, rsync_extra_args=["-a"]
)
# It should have succeeded, with the tasks as retrieved from Pulp
assert sorted(repo.publish(options)) == [
Task(id="task1", succeeded=True, completed=True),
Task(id="task2", succeeded=True, completed=True),
]
req = requests_mocker.request_history
# The yum_distributor request should have set force_full, but not
# delete since it's not recognized by that distributor
assert req[0].json()["override_config"] == {"force_full": True}
# The cdn_distributor request should have set force_full, delete
# and content_units_only
assert req[2].json()["override_config"] == {
"force_full": True,
"delete": True,
"content_units_only": True,
"rsync_extra_args": ["-a"],
}
def test_load_ubiconfig_by_content_set_regex_and_version():
"""Ensure correct config is returned when given a content set regex and version"""
repo = YumRepository(
id="ubi-8-for-x86_64-appstream-rpms__8",
content_set="ubi-8-for-x86_64-appstream-rpms",
)
fake_ubipopulate = FakeUbiPopulate(
"foo.pulp.com",
("foo", "foo"),
False,
ubiconfig_dir_or_url=TEST_DATA_DIR,
version="8",
content_set_regex="x86_64",
)
fake_pulp = fake_ubipopulate.pulp_client_controller
fake_pulp.insert_repository(repo)
# two config files are matched according to testdata
assert len(fake_ubipopulate.ubiconfig_list) == 2
fake_ubipopulate.ubiconfig_list.sort(key=lambda x: x.file_name)
conf_1 = fake_ubipopulate.ubiconfig_list[0]
conf_2 = fake_ubipopulate.ubiconfig_list[1]
assert conf_1.file_name == "ubiconf_golang.yaml"
assert conf_1.content_sets.rpm.output == "ubi-8-for-x86_64-appstream-rpms"
assert conf_2.file_name == "ubiconf_golang2.yaml"
assert conf_2.content_sets.rpm.output == "ubi-8-for-x86_64-appstream-rpms"
def test_can_upload_comps(data_path):
"""repo.upload_comps_xml() succeeds with fake client."""
xml_path = os.path.join(data_path, "sample-comps.xml")
controller = FakeController()
controller.insert_repository(YumRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
upload_f = repo1.upload_comps_xml(xml_path)
# Upload should complete successfully.
tasks = upload_f.result()
# At least one task.
assert tasks
# Every task should have succeeded.
for t in tasks:
assert t.succeeded
# If I now search for all content...
units_all = list(client.search_content())
# There should still be nothing, as the fake does not actually store
# and reproduce comps-related units.
assert units_all == []
def populated_repo(controller):
units = [
RpmUnit(name="bash", version="4.0", release="1", arch="x86_64"),
RpmUnit(content_type_id="srpm",
name="bash",
version="4.0",
release="1",
arch="src"),
RpmUnit(name="glibc", version="5.0", release="1", arch="x86_64"),
ModulemdUnit(name="module1",
stream="s1",
version=1234,
context="a1b2",
arch="x86_64"),
ModulemdUnit(name="module2",
stream="s2",
version=1234,
context="a1b2",
arch="x86_64"),
]
repo = YumRepository(id="repo1")
controller.insert_repository(repo)
controller.insert_units(repo, units)
return controller.client.get_repository(repo.id).result()
def test_search_content_empty_repo(controller):
"""search_content on empty repo gives no results"""
repo = YumRepository(id="empty-repo")
controller.insert_repository(repo)
assert list(
controller.client.get_repository("empty-repo").search_content()) == []
def test_can_upload_rpm_meta(data_path):
rpm_path = os.path.join(data_path, "rpms/walrus-5.21-1.noarch.rpm")
controller = FakeController()
controller.insert_repository(YumRepository(id="repo1"))
client = controller.client
repo1 = client.get_repository("repo1").result()
to_upload = rpm_path
upload_f = repo1.upload_rpm(to_upload, cdn_path="/path/to/my-great.rpm")
# Upload should complete successfully.
tasks = upload_f.result()
# At least one task.
assert tasks
# Every task should have succeeded.
for t in tasks:
assert t.succeeded
# RPM 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 unit.
assert unit.filename == "walrus-5.21-1.noarch.rpm"
# Extra fields we passed during upload should be present here.
assert unit.cdn_path == "/path/to/my-great.rpm"
def test_publish_absent_raises():
"""repo.publish() of a nonexistent repo raises."""
controller = FakeController()
controller.insert_repository(
YumRepository(
id="repo1",
distributors=[
Distributor(id="yum_distributor", type_id="yum_distributor"),
Distributor(id="cdn_distributor",
type_id="rpm_rsync_distributor"),
],
))
client = controller.client
repo_copy1 = client.get_repository("repo1")
repo_copy2 = client.get_repository("repo1")
# If I delete the repo through one handle...
assert repo_copy1.delete().result()
# ...then publish through the other handle becomes impossible
exception = repo_copy2.publish().exception()
assert isinstance(exception, PulpException)
assert "repo1 not found" in str(exception)
def populated_repo(controller):
units = [
RpmUnit(name="bash", version="4.0", release="1", arch="x86_64"),
RpmUnit(content_type_id="srpm",
name="bash",
version="4.0",
release="1",
arch="src"),
RpmUnit(
name="glibc",
version="5.0",
release="1",
arch="x86_64",
sourcerpm="glibc-5.0-1.el5_11.1.src.rpm",
),
ModulemdUnit(name="module1",
stream="s1",
version=1234,
context="a1b2",
arch="x86_64"),
ModulemdUnit(name="module2",
stream="s2",
version=1234,
context="a1b2",
arch="x86_64"),
ErratumUnit(id="RHBA-1234:56", summary="The best advisory"),
]
repo = YumRepository(id="repo1")
controller.insert_repository(repo)
controller.insert_units(repo, units)
return controller.client.get_repository(repo.id).result()
def test_upload_overwrite_noop():
"""repo.upload_erratum() doesn't overwrite erratum unit if version is unmodified."""
controller = FakeController()
controller.insert_repository(YumRepository(id="repo1"))
controller.insert_repository(YumRepository(id="repo2"))
client = controller.client
repo1 = client.get_repository("repo1").result()
repo2 = client.get_repository("repo2").result()
to_upload1 = ErratumUnit(id="RHBA-1234:56",
summary="test advisory",
version="3")
to_upload2 = ErratumUnit(
id="RHBA-1234:56",
summary="updated test advisory",
description="changed it, but no effect due to same version",
version="3",
)
# Upload the advisory to two different repos.
assert repo1.upload_erratum(to_upload1).result()
assert repo2.upload_erratum(to_upload2).result()
# Now let's check the outcome in each repo (and entire system).
units_repo1 = sorted(repo1.search_content(), key=repr)
units_repo2 = sorted(repo2.search_content(), key=repr)
units_all = sorted(client.search_content(), key=repr)
# What we expect to see is that we only have one advisory (as only
# a single id was used), that advisory is present in two repos, and
# the advisory content is equal to the first upload because version
# was not bumped for the second upload.
assert units_repo1 == [
ErratumUnit(
unit_id="e3e70682-c209-4cac-629f-6fbed82c07cd",
id="RHBA-1234:56",
summary="test advisory",
version="3",
repository_memberships=["repo1", "repo2"],
)
]
assert units_repo2 == units_repo1
assert units_all == units_repo1
def test_sync_no_feed(
fast_poller,
client,
requests_mocker,
fixture_sync_async_response,
fixture_search_task_response,
):
"""Test sync fail as no feed is provided."""
repo = YumRepository(id="some-repo")
repo.__dict__["_client"] = client
# empty options should fail as feed is required to be non-empty
try:
repo.sync().result()
assert "Exception should have been raised"
except ValueError:
pass
def fixture_mock_repo():
yield YumRepository(
id="test_repo",
content_set="test_repo-source-rpms",
ubi_config_version="7.9",
ubi_population=True,
population_sources=["a", "b"],
)
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_get_ubi_repo_sets(get_debug_repository, get_source_repository):
content_set = "rhel-8-for-x86_64-appstream-rpms"
repo = YumRepository(
id="ubi_binary",
content_set="rhel-8-for-x86_64-appstream-rpms",
population_sources=["input_binary"],
ubi_population=True,
)
input_binary_repo = YumRepository(id="input_binary")
input_source_repo = YumRepository(id="input_source")
input_debug_repo = YumRepository(id="input_debug")
debug_repo = get_test_repo(id="ubi_source", population_sources=["input_source"])
source_repo = get_test_repo(id="ubi_debug", population_sources=["input_debug"])
get_debug_repository.return_value = debug_repo
get_source_repository.return_value = source_repo
fake_ubipopulate = FakeUbiPopulate(
"foo.pulp.com", ("foo", "foo"), False, ubiconfig_dir_or_url=TEST_DATA_DIR
)
fake_pulp = fake_ubipopulate.pulp_client_controller
fake_pulp.insert_repository(repo)
fake_pulp.insert_repository(input_binary_repo)
fake_pulp.insert_repository(input_source_repo)
fake_pulp.insert_repository(input_debug_repo)
ubi_repo_sets = fake_ubipopulate._get_ubi_repo_sets(content_set)
assert len(ubi_repo_sets) == 1
ubi_repo_set = ubi_repo_sets[0]
input_repos = ubi_repo_set.in_repos
output_repos = ubi_repo_set.out_repos
assert len(input_repos.rpm) == 1
assert input_repos.rpm[0].id == "input_binary"
assert len(input_repos.source) == 1
assert input_repos.source[0].id == "input_source"
assert len(input_repos.debug) == 1
assert input_repos.debug[0].id == "input_debug"
assert output_repos.rpm.id == "ubi_binary"
assert output_repos.source.id == "ubi_source"
assert output_repos.debug.id == "ubi_debug"
def test_bad_comps_xml(client, requests_mocker, tmpdir):
"""A client requested to upload an invalid comps.xml will raise immediately
without making any requests to Pulp."""
repo_id = "repo1"
repo = YumRepository(id=repo_id)
repo.__dict__["_client"] = client
comps_xml = tmpdir.join("comps.xml")
comps_xml.write(b"Oops not valid comps")
# It should raise
with pytest.raises(ExpatError):
repo.upload_comps_xml(str(comps_xml))
# As we did not register anything in requests_mocker, we've already
# implicitly tested that no requests happened. But just to be clear...
assert not requests_mocker.request_history
def test_can_remove_content():
"""repo.remove() succeeds and removes expected units inserted via controller."""
controller = FakeController()
client = controller.client
rpm_units = [
RpmUnit(name="bash", version="4.0", release="1", arch="x86_64"),
RpmUnit(name="glibc", version="5.0", release="1", arch="x86_64"),
]
modulemd_units = [
ModulemdUnit(
name="module1", stream="s1", version=1234, context="a1b2", arch="x86_64"
),
ModulemdUnit(
name="module1", stream="s1", version=1235, context="a1b2", arch="x86_64"
),
]
units = rpm_units + modulemd_units
repo = YumRepository(id="repo1")
controller.insert_repository(repo)
controller.insert_units(repo, units)
remove_rpms = client.get_repository("repo1").remove_content(type_ids=["rpm"])
assert len(remove_rpms) == 1
task = remove_rpms[0]
# It should have completed successfully
assert task.completed
assert task.succeeded
# It should have removed (only) RPM units
assert sorted(task.units) == sorted(rpm_units)
# Now if we ask to remove same content again...
remove_rpms = client.get_repository("repo1").remove_content(type_ids=["rpm"])
assert len(remove_rpms) == 1
task = remove_rpms[0]
# It should have completed successfully, but no RPMs to remove
assert task.completed
assert task.succeeded
assert not task.units
# It should still be possible to remove other content
remove_all = client.get_repository("repo1").remove_content()
assert len(remove_all) == 1
task = remove_all[0]
# It should have completed successfully, and removed the modulemds
assert task.completed
assert task.succeeded
assert sorted(task.units) == sorted(modulemd_units)
def _setup_controller(controller):
# add repo
repo = YumRepository(
id="repo",
eng_product_id=101,
distributors=[],
relative_url="content/unit/1/client",
mutable_urls=["mutable1", "mutable2"],
)
nochannel_repo = YumRepository(
id="all-rpm-content",
eng_product_id=100,
distributors=[],
relative_url="content/unit/1/all-rpm",
mutable_urls=["mutable1", "mutable2"],
)
# add unit
erratum = ErratumUnit(
id="RHSA-1234:56",
version="2",
content_types=["rpm", "module"],
references=[
ErratumReference(
title="title",
href="https://example.com/test-advisory",
type="self",
id="self-id",
),
ErratumReference(
title="CVE-123",
href="https://example.com/test-cve",
type="cve",
id="CVE-123",
),
],
pkglist=[],
repository_memberships=["repo", "all-rpm-content"],
)
controller.insert_repository(repo)
controller.insert_repository(nochannel_repo)
controller.insert_units(repo, [erratum])
controller.insert_units(nochannel_repo, [erratum])
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"))
