def test_positive_capsule_sync(self, capsule_configured, default_sat):
"""Create repository, add it to lifecycle environment, assign lifecycle
environment with a capsule, sync repository, sync it once again, update
repository (add 1 new package), sync repository once again.
:id: 35513099-c918-4a8e-90d0-fd4c87ad2f82
:customerscenario: true
:BZ: 1394354, 1439691
:expectedresults:
1. Repository sync triggers capsule sync
2. After syncing capsule contains same repo content as satellite
3. Syncing repository which has no changes for a second time does
not trigger any new publish task
4. Repository revision on capsule remains exactly the same after
second repo sync with no changes
5. Syncing repository which was updated will update the content on
capsule
:CaseLevel: System
"""
# Create organization, product, repository in satellite, and lifecycle
# environment
repo_url = settings.repos.yum_1.url
org = entities.Organization(
smart_proxy=[capsule_configured.nailgun_capsule.id]).create()
product = entities.Product(organization=org).create()
repo = entities.Repository(product=product, url=repo_url).create()
lce = entities.LifecycleEnvironment(organization=org).create()
# Associate the lifecycle environment with the capsule
capsule_configured.nailgun_capsule.content_add_lifecycle_environment(
data={'environment_id': lce.id})
result = capsule_configured.nailgun_capsule.content_lifecycle_environments(
)
assert len(result['results'])
assert lce.id in [
capsule_lce['id'] for capsule_lce in result['results']
]
# Create a content view with the repository
cv = entities.ContentView(organization=org, repository=[repo]).create()
# Sync repository
repo.sync()
repo = repo.read()
# Publish new version of the content view
cv.publish()
cv = cv.read()
assert len(cv.version) == 1
cvv = cv.version[-1].read()
# Promote content view to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
assert len(cvv.environment) == 2
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule_configured.nailgun_capsule.content_get_sync()
assert len(
sync_status['active_sync_tasks']) or sync_status['last_sync_time']
# Content of the published content view in
# lifecycle environment should equal content of the
# repository
assert repo.content_counts['package'] == cvv.package_count
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
sync_status = capsule_configured.nailgun_capsule.content_get_sync()
last_sync_time = sync_status['last_sync_time']
# Assert that the content published on the capsule is exactly the
# same as in repository on satellite
sat_repo_url = form_repo_url(
default_sat,
org=org.label,
lce=lce.label,
cv=cv.label,
prod=product.label,
repo=repo.label,
)
caps_repo_url = form_repo_url(
capsule_configured,
org=org.label,
lce=lce.label,
cv=cv.label,
prod=product.label,
repo=repo.label,
)
sat_files = get_repo_files_by_url(sat_repo_url)
caps_files = get_repo_files_by_url(caps_repo_url)
assert sat_files == caps_files
lce_revision_capsule = get_repomd_revision(caps_repo_url)
# Sync repository for a second time
result = repo.sync()
# Assert that the task summary contains a message that says the
# publish was skipped because content had not changed
assert result['result'] == 'success'
assert result['output']['post_action_skipped']
assert 'Associating Content: 0/0' in result['humanized']['output']
# Publish a new version of content view
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
# Promote new content view version to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
assert len(cvv.environment) == 2
# Wait till capsule sync finishes
sync_status = capsule_configured.nailgun_capsule.content_get_sync()
tasks = []
if not sync_status['active_sync_tasks']:
assert sync_status['last_sync_time'] != last_sync_time
else:
for task in sync_status['active_sync_tasks']:
tasks.append(entities.ForemanTask(id=task['id']))
tasks[-1].poll()
# Assert that the value of repomd revision of repository in
# lifecycle environment on the capsule has not changed
new_lce_revision_capsule = get_repomd_revision(caps_repo_url)
assert lce_revision_capsule == new_lce_revision_capsule
# Update a repository with 1 new rpm
with open(get_data_file(constants.RPM_TO_UPLOAD), 'rb') as handle:
repo.upload_content(files={'content': handle})
# Publish and promote the repository
repo = repo.read()
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
promote(cvv, lce.id)
cvv = cvv.read()
assert len(cvv.environment) == 2
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule_configured.nailgun_capsule.content_get_sync()
assert (len(sync_status['active_sync_tasks'])
or sync_status['last_sync_time'] != last_sync_time)
# Assert that packages count in the repository is updated
assert repo.content_counts['package'] == (
constants.FAKE_1_YUM_REPOS_COUNT + 1)
# Assert that the content of the published content view in
# lifecycle environment is exactly the same as content of the
# repository
assert repo.content_counts['package'] == cvv.package_count
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
# Assert that the content published on the capsule is exactly the
# same as in the repository
sat_files = get_repo_files_by_url(sat_repo_url)
caps_files = get_repo_files_by_url(caps_repo_url)
assert sat_files == caps_files
def test_positive_capsule_sync(self):
"""Create repository, add it to lifecycle environment, assign lifecycle
environment with a capsule, sync repository, sync it once again, update
repository (add 1 new package), sync repository once again.
:id: 35513099-c918-4a8e-90d0-fd4c87ad2f82
:customerscenario: true
:BZ: 1394354, 1439691
:expectedresults:
1. Repository sync triggers capsule sync
2. After syncing capsule contains same repo content as satellite
3. Syncing repository which has no changes for a second time does
not trigger any new publish task
4. Repository revision on capsule remains exactly the same after
second repo sync with no changes
5. Syncing repository which was updated will update the content on
capsule
:CaseLevel: System
"""
repo_name = gen_string('alphanumeric')
# Create and publish custom repository with 2 packages in it
repo_url = create_repo(
repo_name,
FAKE_1_YUM_REPO,
FAKE_1_YUM_REPO_RPMS[0:2],
)
# Create organization, product, repository in satellite, and lifecycle
# environment
org = entities.Organization(smart_proxy=[self.capsule_id]).create()
product = entities.Product(organization=org).create()
repo = entities.Repository(
product=product,
url=repo_url,
).create()
lce = entities.LifecycleEnvironment(organization=org).create()
# Associate the lifecycle environment with the capsule
capsule = entities.Capsule(id=self.capsule_id).read()
capsule.content_add_lifecycle_environment(data={
'environment_id': lce.id,
})
result = capsule.content_lifecycle_environments()
self.assertGreaterEqual(len(result['results']), 1)
self.assertIn(lce.id,
[capsule_lce['id'] for capsule_lce in result['results']])
# Create a content view with the repository
cv = entities.ContentView(
organization=org,
repository=[repo],
).create()
# Sync repository
repo.sync()
repo = repo.read()
# Publish new version of the content view
cv.publish()
cv = cv.read()
self.assertEqual(len(cv.version), 1)
cvv = cv.version[-1].read()
# Promote content view to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time'])
# Assert that the content of the published content view in
# lifecycle environment is exactly the same as content of
# repository
lce_repo_path = form_repo_path(
org=org.label,
lce=lce.label,
cv=cv.label,
prod=product.label,
repo=repo.label,
)
cvv_repo_path = form_repo_path(
org=org.label,
cv=cv.label,
cvv=cvv.version,
prod=product.label,
repo=repo.label,
)
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
sync_status = capsule.content_get_sync()
last_sync_time = sync_status['last_sync_time']
# If BZ1439691 is open, need to sync repo once more, as repodata
# will change on second attempt even with no changes in repo
if is_open('BZ:1439691'):
repo.sync()
repo = repo.read()
cv.publish()
cv = cv.read()
self.assertEqual(len(cv.version), 2)
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time'] != last_sync_time)
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
sync_status = capsule.content_get_sync()
last_sync_time = sync_status['last_sync_time']
# Assert that the content published on the capsule is exactly the
# same as in repository on satellite
lce_revision_capsule = get_repomd_revision(lce_repo_path,
hostname=self.capsule_ip)
self.assertEqual(
get_repo_files(lce_repo_path, hostname=self.capsule_ip),
get_repo_files(cvv_repo_path))
# Sync repository for a second time
result = repo.sync()
# Assert that the task summary contains a message that says the
# publish was skipped because content had not changed
self.assertEqual(result['result'], 'success')
self.assertTrue(result['output']['post_sync_skipped'])
self.assertEqual(result['humanized']['output'], 'No new packages.')
# Publish a new version of content view
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
# Promote new content view version to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Wait till capsule sync finishes
sync_status = capsule.content_get_sync()
tasks = []
if not sync_status['active_sync_tasks']:
self.assertNotEqual(sync_status['last_sync_time'], last_sync_time)
else:
for task in sync_status['active_sync_tasks']:
tasks.append(entities.ForemanTask(id=task['id']))
tasks[-1].poll()
# Assert that the value of repomd revision of repository in
# lifecycle environment on the capsule has not changed
new_lce_revision_capsule = get_repomd_revision(
lce_repo_path, hostname=self.capsule_ip)
self.assertEqual(lce_revision_capsule, new_lce_revision_capsule)
# Update a repository with 1 new rpm
create_repo(
repo_name,
FAKE_1_YUM_REPO,
FAKE_1_YUM_REPO_RPMS[-1:],
)
# Sync, publish and promote the repository
repo.sync()
repo = repo.read()
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time'] != last_sync_time)
# Assert that packages count in the repository is updated
self.assertEqual(repo.content_counts['package'], 3)
# Assert that the content of the published content view in
# lifecycle environment is exactly the same as content of the
# repository
cvv_repo_path = form_repo_path(
org=org.label,
cv=cv.label,
cvv=cvv.version,
prod=product.label,
repo=repo.label,
)
self.assertEqual(
repo.content_counts['package'],
cvv.package_count,
)
self.assertEqual(get_repo_files(lce_repo_path),
get_repo_files(cvv_repo_path))
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
# Assert that the content published on the capsule is exactly the
# same as in the repository
self.assertEqual(
get_repo_files(lce_repo_path, hostname=self.capsule_ip),
get_repo_files(cvv_repo_path))
def test_positive_capsule_sync(self):
"""Create repository, add it to lifecycle environment, assign lifecycle
environment with a capsule, sync repository, sync it once again, update
repository (add 1 new package), sync repository once again.
:id: 35513099-c918-4a8e-90d0-fd4c87ad2f82
:customerscenario: true
:BZ: 1394354
:expectedresults:
1. Repository sync triggers capsule sync
2. After syncing capsule contains same repo content as satellite
3. Syncing repository which has no changes for a second time does
not trigger any new publish task
4. Repository revision on capsule remains exactly the same after
second repo sync with no changes
5. Syncing repository which was updated will update the content on
capsule
:CaseLevel: System
"""
repo_name = gen_string('alphanumeric')
# Create and publish custom repository with 2 packages in it
repo_url = create_repo(
repo_name,
FAKE_1_YUM_REPO,
FAKE_1_YUM_REPO_RPMS[0:2],
)
# Create organization, product, repository in satellite, and lifecycle
# environment
org = entities.Organization(smart_proxy=[self.capsule_id]).create()
product = entities.Product(organization=org).create()
repo = entities.Repository(
product=product,
url=repo_url,
).create()
lce = entities.LifecycleEnvironment(organization=org).create()
# Associate the lifecycle environment with the capsule
capsule = entities.Capsule(id=self.capsule_id).read()
capsule.content_add_lifecycle_environment(data={
'environment_id': lce.id,
})
result = capsule.content_lifecycle_environments()
self.assertGreaterEqual(len(result['results']), 1)
self.assertIn(
lce.id, [capsule_lce['id'] for capsule_lce in result['results']])
# Create a content view with the repository
cv = entities.ContentView(
organization=org,
repository=[repo],
).create()
# Sync repository
repo.sync()
repo = repo.read()
# Publish new version of the content view
cv.publish()
cv = cv.read()
self.assertEqual(len(cv.version), 1)
cvv = cv.version[-1].read()
# Promote content view to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time']
)
# Assert that the content of the published content view in
# lifecycle environment is exactly the same as content of
# repository
lce_repo_path = form_repo_path(
org=org.label,
lce=lce.label,
cv=cv.label,
prod=product.label,
repo=repo.label,
)
cvv_repo_path = form_repo_path(
org=org.label,
cv=cv.label,
cvv=cvv.version,
prod=product.label,
repo=repo.label,
)
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
sync_status = capsule.content_get_sync()
last_sync_time = sync_status['last_sync_time']
# If BZ1439691 is open, need to sync repo once more, as repodata
# will change on second attempt even with no changes in repo
if bz_bug_is_open(1439691):
repo.sync()
repo = repo.read()
cv.publish()
cv = cv.read()
self.assertEqual(len(cv.version), 2)
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time'] != last_sync_time
)
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
sync_status = capsule.content_get_sync()
last_sync_time = sync_status['last_sync_time']
# Assert that the content published on the capsule is exactly the
# same as in repository on satellite
lce_revision_capsule = get_repomd_revision(
lce_repo_path, hostname=self.capsule_ip)
self.assertEqual(
get_repo_files(lce_repo_path, hostname=self.capsule_ip),
get_repo_files(cvv_repo_path)
)
# Sync repository for a second time
result = repo.sync()
# Assert that the task summary contains a message that says the
# publish was skipped because content had not changed
self.assertEqual(result['result'], 'success')
self.assertTrue(result['output']['post_sync_skipped'])
self.assertEqual(
result['humanized']['output'],
'No new packages.'
)
# Publish a new version of content view
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
# Promote new content view version to lifecycle environment
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Wait till capsule sync finishes
sync_status = capsule.content_get_sync()
tasks = []
if not sync_status['active_sync_tasks']:
self.assertNotEqual(
sync_status['last_sync_time'], last_sync_time)
else:
for task in sync_status['active_sync_tasks']:
tasks.append(entities.ForemanTask(id=task['id']))
tasks[-1].poll()
# Assert that the value of repomd revision of repository in
# lifecycle environment on the capsule has not changed
new_lce_revision_capsule = get_repomd_revision(
lce_repo_path, hostname=self.capsule_ip)
self.assertEqual(lce_revision_capsule, new_lce_revision_capsule)
# Update a repository with 1 new rpm
create_repo(
repo_name,
FAKE_1_YUM_REPO,
FAKE_1_YUM_REPO_RPMS[-1:],
)
# Sync, publish and promote the repository
repo.sync()
repo = repo.read()
cv.publish()
cv = cv.read()
cv.version.sort(key=lambda version: version.id)
cvv = cv.version[-1].read()
promote(cvv, lce.id)
cvv = cvv.read()
self.assertEqual(len(cvv.environment), 2)
# Assert that a task to sync lifecycle environment to the capsule
# is started (or finished already)
sync_status = capsule.content_get_sync()
self.assertTrue(
len(sync_status['active_sync_tasks']) >= 1
or sync_status['last_sync_time'] != last_sync_time
)
# Assert that packages count in the repository is updated
self.assertEqual(repo.content_counts['package'], 3)
# Assert that the content of the published content view in
# lifecycle environment is exactly the same as content of the
# repository
cvv_repo_path = form_repo_path(
org=org.label,
cv=cv.label,
cvv=cvv.version,
prod=product.label,
repo=repo.label,
)
self.assertEqual(
repo.content_counts['package'],
cvv.package_count,
)
self.assertEqual(
get_repo_files(lce_repo_path),
get_repo_files(cvv_repo_path)
)
# Wait till capsule sync finishes
for task in sync_status['active_sync_tasks']:
entities.ForemanTask(id=task['id']).poll()
# Assert that the content published on the capsule is exactly the
# same as in the repository
self.assertEqual(
get_repo_files(lce_repo_path, hostname=self.capsule_ip),
get_repo_files(cvv_repo_path)
)
