def test_multiple_repos(self): """ Tests saving and loading multiple repos. """ # Setup repo1 = Repo('test-repo-1') repo1['baseurl'] = 'http://localhost/repo1' repo2 = Repo('test-repo-2') repo2['baseurl'] = 'http://localhost/repo2' repo_file = RepoFile(TEST_REPO_FILENAME) # Test repo_file.add_repo(repo1) repo_file.add_repo(repo2) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() self.assertEqual(2, len(loaded.all_repos())) found_repo1 = loaded.get_repo('test-repo-1') self.assertTrue(found_repo1 is not None) self.assertTrue(_repo_eq(repo1, found_repo1)) found_repo2 = loaded.get_repo('test-repo-2') self.assertTrue(found_repo2 is not None) self.assertTrue(_repo_eq(repo2, found_repo2))
def test_unbind_repo_exists(self): """ Tests the normal case of unbinding a repo that exists in the repo file. """ # Setup repoid = 'test-unbind-repo' repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.add_repo(Repo(repoid)) repo_file.save() # Test repolib.unbind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, 'test-unbind-repo', self.LOCK) # verify repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load( allow_missing=False) # the file should still be there, so error if it doesn't self.assertEqual(0, len(repo_file.all_repos())) certdir = os.path.join(self.TEST_CERT_DIR, repoid) self.assertFalse(os.path.exists(certdir))
def test_delete_repo(self): """ Tests removing an existing repo is correctly saved and loaded """ # Setup repo1 = Repo('test-repo-1') repo2 = Repo('test-repo-2') repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo1) repo_file.add_repo(repo2) repo_file.save() # Test repo_file.remove_repo_by_name('test-repo-1') repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() self.assertEqual(1, len(loaded.all_repos())) self.assertTrue(loaded.get_repo('test-repo-1') is None) self.assertTrue(loaded.get_repo('test-repo-2') is not None)
def test_update_repo(self): """ Tests that updating an existing repo is correctly saved. """ # Setup repo1 = Repo('test-repo-1') repo1['baseurl'] = 'http://localhost/repo1' repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo1) repo_file.save() # Test repo1['baseurl'] = 'http://localhost/repo-updated' repo_file.update_repo(repo1) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() found_repo = loaded.get_repo('test-repo-1') self.assertEqual(found_repo['baseurl'], 'http://localhost/repo-updated')
def test_one_repo_save_and_load(self): """ Tests the normal flow of saving and loading, using only one repo to minimize complications. """ # Setup add_me = Repo('test-repo-1') add_me['baseurl'] = 'http://localhost/repo' add_me['enabled'] = 1 add_me['gpgkey'] = '/tmp/key' add_me['sslverify'] = 1 add_me['gpgcheck'] = 0 add_me['sslcacert'] = '/tmp/sslcacert' add_me['sslclientcert'] = '/tmp/clientcert' repo_file = RepoFile(TEST_REPO_FILENAME) # Test Save repo_file.add_repo(add_me) repo_file.save() # Verify Save self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) # Test Load loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() # Verify Load self.assertEqual(1, len(loaded.all_repos())) found_repo = loaded.get_repo('test-repo-1') self.assertTrue(found_repo is not None) self.assertTrue(_repo_eq(add_me, found_repo))
def test_no_repos_save_load(self): """ Tests that saving and loading a file with no repos is successful. """ # Test repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() # Verify self.assertEqual(0, len(loaded.all_repos()))
def test_clear_clientcert(self): # setup repolib.bind( self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CLIENTCERT, ENABLED, self.LOCK) repolib.bind( self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], None, ENABLED, self.LOCK, verify_ssl=True) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) certdir = os.path.join(self.TEST_CERT_DIR, REPO_ID) self.assertFalse(os.path.exists(certdir)) self.assertTrue(loaded['sslverify'], '1')
def test_bind_new_file(self): """ Tests binding a repo when the underlying .repo file does not exist. """ url_list = ['http://pulpserver'] repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, CLIENTCERT, ENABLED, self.LOCK) self.assertTrue(os.path.exists(self.TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(self.TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() self.assertEqual(1, len(repo_file.all_repos())) loaded = repo_file.get_repo(REPO_ID) self.assertTrue(loaded is not None) self.assertEqual(loaded['name'], REPO_NAME) self.assertTrue(loaded['enabled']) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(CLIENTCERT, content) # verify_ssl defaults to True self.assertTrue(loaded['sslverify'], '1') self.assertEqual(loaded['sslcacert'], DEFAULT_CA_PATH)
def test_bind_new_repo_no_name(self): """ Tests binding a repository that doesn't exist without providing a name. """ url_list = ['http://pulpserver'] repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, None, url_list, {}, CLIENTCERT, ENABLED, self.LOCK) self.assertTrue(os.path.exists(self.TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(self.TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() self.assertEqual(1, len(repo_file.all_repos())) loaded = repo_file.get_repo(REPO_ID) self.assertTrue(loaded is not None) self.assertEqual(loaded['name'], REPO_ID) self.assertTrue(loaded['enabled']) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded)
def test_bind_update_keys(self): """ Tests changing the GPG keys on a previously bound repo. """ keys = {'key1': 'KEY1', 'key2': 'KEY2'} repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], keys, None, ENABLED, self.LOCK) new_keys = {'key1': 'KEYX'} repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, None, None, new_keys, None, ENABLED, self.LOCK) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '1') self.assertEqual(1, len(loaded['gpgkey'].split('\n'))) self.assertEqual(1, len(os.listdir(os.path.join(self.TEST_KEYS_DIR, REPO_ID)))) key_file = open(loaded['gpgkey'].split('\n')[0][5:], 'r') contents = key_file.read() key_file.close() self.assertEqual(contents, 'KEYX')
def test_clear_ca_path(self): repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CLIENTCERT, ENABLED, LOCK, verify_ssl=True, ca_path='/some/path') repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CLIENTCERT, ENABLED, LOCK) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) certdir = os.path.join(TEST_CERT_DIR, REPO_ID) self.assertTrue(len(os.listdir(certdir)), 1) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(CLIENTCERT, content) self.assertTrue(loaded['sslverify'], '0')
def test_broken_load_allow_missing(self): """ Tests that an exception is raised when the file cannot be loaded because it is not found. """ # Test repo_file = RepoFile('/a/b/c/d') repo_file.load(allow_missing=True)
def test_broken_load(self): """ Tests that an exception is raised when the file cannot be loaded because it is not found. """ # Test repo_file = RepoFile('/a/b/c/d') self.assertRaises(IOError, repo_file.load, allow_missing=False)
def test_delete_file_doesnt_exist(self): """ Tests that deleting when the file doesn't exist does *not* throw an error. """ # Setup self.assertTrue(not os.path.exists(TEST_REPO_FILENAME)) # Test repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.delete()
def test_add_duplicate(self): """ Tests that adding a repo that already exists throws a duplication error. """ # Setup repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(Repo('foo')) # Test self.assertRaises(DuplicateSectionError, repo_file.add_repo, Repo('foo'))
def test_broken_save(self): """ Tests that an exception is raised when the file cannot be saved. """ # Test # RepoFile will not create these directories so it should fail if this structure # does not exist. repo_file = RepoFile('/a/b/c/d') self.assertRaises(IOError, repo_file.save)
def test_baseurl_not_mirrorlist(self): """ Tests that if a baseurl is specified, a mirrorlist entry isn't written to the saved repo file. """ # Setup repo = Repo('test-repo-1') repo['baseurl'] = 'http://localhost' repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo) repo_file.save() # Test loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() loaded_repo = loaded.get_repo('test-repo-1') self.assertEqual(loaded_repo['baseurl'], 'http://localhost') self.assertTrue('mirrorlist' not in loaded_repo)
def test_get_invalid_repo(self): """ Makes sure None is returned when requesting a repo that doesn't exist instead of throwing an error. """ # Setup repo_file = RepoFile(TEST_REPO_FILENAME) # Test found = repo_file.get_repo('foo') # Verify self.assertTrue(found is None)
def test_broken_load_invalid_data(self): """ Tests that an exception is raised when the file contains non-parsable data. """ # Setup f = open(TEST_REPO_FILENAME, 'w') f.write('This is not parsable.') f.close() # Test repo_file = RepoFile(TEST_REPO_FILENAME) self.assertRaises(Exception, repo_file.load)
def test_bind_existing_file(self): """ Tests binding a new repo when the underlying file exists and has repos in it (the existing repo shouldn't be deleted). """ # Setup repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.add_repo(Repo('existing-repo-1')) repo_file.save() # Test url_list = ['http://pulpserver'] repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, ENABLED, self.LOCK) # Verify self.assertTrue(os.path.exists(self.TEST_REPO_FILENAME)) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() self.assertEqual(2, len(repo_file.all_repos()))
def test_delete_repo_no_repo(self): """ Ensures that an error is not thrown when a repo that does not exist is deleted from the repo file. """ # Setup repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(Repo('test-repo-1')) # Test repo_file.remove_repo_by_name('foo') # Verify self.assertTrue(repo_file.get_repo('test-repo-1') is not None)
def test_header(self): """ Tests that the pulp header is properly written in the generated file. """ # Setup repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.save() # Test f = open(TEST_REPO_FILENAME, 'r') contents = f.read() f.close() # Verify self.assertTrue(contents.startswith(RepoFile.FILE_HEADER))
def test_bind_multiple_keys(self): """ Tests that binding with multiple key URLs correctly stores the repo entry. """ url_list = ['http://pulpserver'] keys = {'key1': 'KEY1', 'key2': 'KEY2'} repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, keys, None, ENABLED, self.LOCK) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '1') self.assertEqual(2, len(loaded['gpgkey'].split('\n'))) self.assertEqual(2, len(os.listdir(os.path.join(self.TEST_KEYS_DIR, REPO_ID))))
def test_bind_single_url(self): """ Tests that binding with a single URL will produce a baseurl in the repo. """ url_list = ['http://pulpserver'] repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, ENABLED, self.LOCK) self.assertTrue(os.path.exists(self.TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(self.TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded)
def test_bind_ssl_verify_true_explicit_ca_path(self): """ Tests binding a repo with verify_ssl set explicitly to True and an explicit ca_path. """ url_list = ['http://pulpserver'] ca_path = '/some/path' repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, CLIENTCERT, ENABLED, LOCK, verify_ssl=True, ca_path=ca_path) self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() self.assertEqual(1, len(repo_file.all_repos())) loaded = repo_file.get_repo(REPO_ID) self.assertTrue(loaded is not None) self.assertEqual(loaded['name'], REPO_NAME) self.assertTrue(loaded['enabled']) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(CLIENTCERT, content) self.assertTrue(loaded['sslverify'], '1') # The default CA path should have been used self.assertEqual(loaded['sslcacert'], ca_path)
def test_update_ca_path(self): NEW_PATH = '/new/path/' repolib.bind( self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CLIENTCERT, ENABLED, self.LOCK, verify_ssl=True, ca_path='/some/path/') repolib.bind( self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CLIENTCERT, ENABLED, self.LOCK, verify_ssl=True, ca_path=NEW_PATH) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) certdir = os.path.join(self.TEST_CERT_DIR, REPO_ID) self.assertTrue(len(os.listdir(certdir)), 1) path = loaded['sslcacert'] self.assertEqual(path, NEW_PATH) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(CLIENTCERT, content) self.assertTrue(loaded['sslverify'], '1')
def test_delete_repofile(self): """ Tests that deleting a RepoFile correctly deletes the file on disk. """ # Setup self.assertTrue(not os.path.exists(TEST_REPO_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.save() self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) # Test repo_file.delete() # Verify self.assertTrue(not os.path.exists(TEST_REPO_FILENAME))
def test_unbind_repo_with_mirrorlist(self): """ Tests that unbinding a repo that had a mirror list deletes the mirror list file. """ url_list = ['http://pulp1', 'http://pulp2', 'http://pulp3'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, ENABLED, LOCK) self.assertTrue(os.path.exists(TEST_MIRROR_LIST_FILENAME)) repolib.unbind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, LOCK) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() self.assertEqual(0, len(repo_file.all_repos())) self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME))
def test_bind_update_repo(self): """ Tests calling bind on an existing repo with new repo data. The host URL and key data remain unchanged. """ url_list = ['http://pulp1', 'http://pulp2'] repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, None, None, ENABLED, self.LOCK) updated_name = 'Updated' repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, updated_name, None, None, None, ENABLED, self.LOCK) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['name'], updated_name)
def test_bind_update_remove_keys(self): """ Tests that updating a previously bound repo by removing its keys correctly configures the repo and deletes the key files. """ keys = {'key1': 'KEY1', 'key2': 'KEY2'} repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], keys, None, ENABLED, self.LOCK) repolib.bind(self.TEST_REPO_FILENAME, self.TEST_MIRROR_LIST_FILENAME, self.TEST_KEYS_DIR, self.TEST_CERT_DIR, REPO_ID, None, None, {}, None, ENABLED, self.LOCK) repo_file = RepoFile(self.TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertTrue(not os.path.exists(os.path.join(self.TEST_KEYS_DIR, REPO_ID)))