class TestProxyCache(unittest.TestCase): @classmethod def setUpClass(self): self.url = ADMIN_CLIENT["endpoint"] self.user_password = "******" self.project = Project() self.user = User() self.repo = Repository() self.registry = Registry() self.artifact = Artifact() @classmethod def tearDownClass(self): print("Case completed") def do_validate(self, registry_type): """ Test case: Proxy Cache Image From Harbor Test step and expected result: 1. Create a new registry; 2. Create a new project; 3. Add a new user as a member of project; 4. Pull image from this project by docker CLI; 5. Pull image from this project by ctr CLI; 6. Pull manifest index from this project by docker CLI; 7. Pull manifest from this project by ctr CLI; 8. Image pulled by docker CLI should be cached; 9. Image pulled by ctr CLI should be cached; 10. Manifest index pulled by docker CLI should be cached; 11. Manifest index pulled by ctr CLI should be cached; Tear down: 1. Delete project(PA); 2. Delete user(UA). """ user_id, user_name = self.user.create_user( user_password=self.user_password, **ADMIN_CLIENT) USER_CLIENT = dict(with_signature=True, endpoint=self.url, username=user_name, password=self.user_password) image_for_docker = dict(image="for_proxy", tag="1.0") image_for_ctr = dict(image="redis", tag="latest") index_for_docker = dict(image="index081597864867", tag="index_tag081597864867") access_key = "" access_secret = "" #1. Create a new registry; if registry_type == "docker-hub": user_namespace = "danfengliu" access_key = user_namespace access_secret = "Aa123456" registry = "https://hub.docker.com" # Memo: ctr will not send image pull request if manifest list already exist, so we pull different manifest list for different registry; index_for_ctr = dict(image="alpine", tag="3.12.0") else: user_namespace = "nightly" registry = "https://cicd.harbor.vmwarecna.net" index_for_ctr = dict(image="busybox", tag="1.32.0") registry_id, _ = self.registry.create_registry( registry, name=_random_name(registry_type), registry_type=registry_type, access_key=access_key, access_secret=access_secret, insecure=False, **ADMIN_CLIENT) print("registry_id:", registry_id) #2. Create a new project; project_id, project_name = self.project.create_project( registry_id=registry_id, metadata={"public": "false"}, **ADMIN_CLIENT) print("project_id:", project_id) print("project_name:", project_name) #3. Add a new user as a member of project; self.project.add_project_members(project_id, user_id=user_id, **ADMIN_CLIENT) #4. Pull image from this project by docker CLI; pull_harbor_image( harbor_server, USER_CLIENT["username"], USER_CLIENT["password"], project_name + "/" + user_namespace + "/" + image_for_docker["image"], image_for_docker["tag"]) #5. Pull image from this project by ctr CLI; oci_ref = harbor_server + "/" + project_name + "/" + user_namespace + "/" + image_for_ctr[ "image"] + ":" + image_for_ctr["tag"] library.containerd.ctr_images_pull(user_name, self.user_password, oci_ref) library.containerd.ctr_images_list(oci_ref=oci_ref) #6. Pull manifest index from this project by docker CLI; index_repo_name = user_namespace + "/" + index_for_docker["image"] pull_harbor_image(harbor_server, user_name, self.user_password, project_name + "/" + index_repo_name, index_for_docker["tag"]) #7. Pull manifest from this project by ctr CLI; index_repo_name_for_ctr = user_namespace + "/" + index_for_ctr["image"] oci_ref = harbor_server + "/" + project_name + "/" + index_repo_name_for_ctr + ":" + index_for_ctr[ "tag"] library.containerd.ctr_images_pull(user_name, self.user_password, oci_ref) library.containerd.ctr_images_list(oci_ref=oci_ref) #8. Image pulled by docker CLI should be cached; self.artifact.waiting_for_reference_exist( project_name, urllib.parse.quote( user_namespace + "/" + image_for_docker["image"], 'utf-8'), image_for_docker["tag"], **USER_CLIENT) #9. Image pulled by ctr CLI should be cached; self.artifact.waiting_for_reference_exist( project_name, urllib.parse.quote(user_namespace + "/" + image_for_ctr["image"], 'utf-8'), image_for_ctr["tag"], **USER_CLIENT) #10. Manifest index pulled by docker CLI should be cached; ret_index_by_d = self.artifact.waiting_for_reference_exist( project_name, urllib.parse.quote(index_repo_name, 'utf-8'), index_for_docker["tag"], **USER_CLIENT) print("Index's reference by docker CLI:", ret_index_by_d[0].references) self.assertTrue(len(ret_index_by_d[0].references) == 1) #11. Manifest index pulled by ctr CLI should be cached; ret_index_by_c = self.artifact.waiting_for_reference_exist( project_name, urllib.parse.quote(index_repo_name_for_ctr, 'utf-8'), index_for_ctr["tag"], **USER_CLIENT) print("Index's reference by ctr CLI:", ret_index_by_c[0].references) self.assertTrue(len(ret_index_by_c[0].references) == 1) def test_proxy_cache_from_harbor(self): self.do_validate("harbor") def test_proxy_cache_from_dockerhub(self): self.do_validate("docker-hub") def suite(): suite = unittest.TestSuite(unittest.makeSuite(TestProxyCache)) return suite
class TestProjects(unittest.TestCase): @suppress_urllib3_warning def setUp(self): self.project = Project() self.user = User() self.replication = Replication() self.replication_v2 = ReplicationV2() self.registry = Registry() self.artifact = Artifact() self.repo = Repository() self.image = "alpine" self.tag = "latest" @unittest.skipIf(TEARDOWN == False, "Test data won't be erased.") def tearDown(self): #1. Delete rule(RA); self.replication.delete_replication_rule(TestProjects.rule_id, **ADMIN_CLIENT) #2. Delete registry(TA); self.registry.delete_registry(TestProjects.registry_id, **ADMIN_CLIENT) #1. Delete repository(RA); self.repo.delete_repoitory(TestProjects.project_name, self.image, **TestProjects.USER_add_rule_CLIENT) #3. Delete project(PA); self.project.delete_project(TestProjects.project_add_rule_id, **TestProjects.USER_add_rule_CLIENT) #4. Delete user(UA); self.user.delete_user(TestProjects.user_add_rule_id, **ADMIN_CLIENT) def testReplicationFromDockerhub(self): """ Test case: Replication From Dockerhub Test step and expected result: 1. Create a new user(UA); 2. Create a new private project(PA) by user(UA); 3. Create a new registry; 4. Create a new rule for this registry; 5. Check rule should be exist; 6. Trigger the rule; 7. Wait for completion of this replication job; 8. Check image is replicated into target project successfully. Tear down: 1. Delete rule(RA); 2. Delete registry(TA); 3. Delete project(PA); 4. Delete user(UA). """ url = ADMIN_CLIENT["endpoint"] user_add_rule_password = "******" #1. Create user(UA) TestProjects.user_add_rule_id, user_add_rule_name = self.user.create_user( user_password=user_add_rule_password, **ADMIN_CLIENT) TestProjects.USER_add_rule_CLIENT = dict( endpoint=url, username=user_add_rule_name, password=user_add_rule_password) #2.1. Create private project(PA) by user(UA) TestProjects.project_add_rule_id, TestProjects.project_name = self.project.create_project( metadata={"public": "false"}, **TestProjects.USER_add_rule_CLIENT) #2.2. Get private project of uesr-001, uesr-001 can see only one private project which is project-001 self.project.projects_should_exist( dict(public=False), expected_count=1, expected_project_id=TestProjects.project_add_rule_id, **TestProjects.USER_add_rule_CLIENT) #3. Create a new registry; TestProjects.registry_id, _ = self.registry.create_registry( "https://hub.docker.com", registry_type="docker-hub", access_key=DOCKER_USER, access_secret=DOCKER_PWD, insecure=False, **ADMIN_CLIENT) #4. Create a pull-based rule for this registry; TestProjects.rule_id, rule_name = self.replication.create_replication_policy( src_registry=swagger_client.Registry( id=int(TestProjects.registry_id)), dest_namespace=TestProjects.project_name, filters=[ swagger_client.ReplicationFilter(type="name", value="library/" + self.image), swagger_client.ReplicationFilter(type="tag", value=self.tag) ], **ADMIN_CLIENT) #5. Check rule should be exist; self.replication.check_replication_rule_should_exist( TestProjects.rule_id, rule_name, **ADMIN_CLIENT) #6. Trigger the rule; self.replication_v2.trigger_replication_executions( TestProjects.rule_id, **ADMIN_CLIENT) #7. Wait for completion of this replication job; self.replication_v2.wait_until_jobs_finish(TestProjects.rule_id, interval=30, **ADMIN_CLIENT) #8. Check image is replicated into target project successfully. artifact = self.artifact.get_reference_info(TestProjects.project_name, self.image, self.tag, **ADMIN_CLIENT)
class TestProjects(unittest.TestCase): @suppress_urllib3_warning def setUp(self): self.project = Project() self.user = User() self.replication = Replication() self.registry = Registry() @unittest.skipIf(TEARDOWN == False, "Test data won't be erased.") def tearDown(self): #1. Delete rule(RA); self.replication.delete_replication_rule(TestProjects.rule_id, **ADMIN_CLIENT) #2. Delete registry(TA); self.registry.delete_registry(TestProjects.registry_id, **ADMIN_CLIENT) #3. Delete project(PA); self.project.delete_project(TestProjects.project_add_rule_id, **TestProjects.USER_add_rule_CLIENT) #4. Delete user(UA); self.user.delete_user(TestProjects.user_add_rule_id, **ADMIN_CLIENT) def testAddReplicationRule(self): """ Test case: Add Replication Rule Test step and expected result: 1. Create a new user(UA); 2. Create a new private project(PA) by user(UA); 3. Create a new registry; 4. Create a new rule for this registry; 5. Check rule should be exist. Tear down: 1. Delete rule(RA); 2. Delete registry(TA); 3. Delete project(PA); 4. Delete user(UA). """ url = ADMIN_CLIENT["endpoint"] user_add_rule_password = "******" #1. Create user(UA) TestProjects.user_add_rule_id, user_add_rule_name = self.user.create_user(user_password = user_add_rule_password, **ADMIN_CLIENT) TestProjects.USER_add_rule_CLIENT=dict(endpoint = url, username = user_add_rule_name, password = user_add_rule_password) #2.1. Create private project(PA) by user(UA) TestProjects.project_add_rule_id, _ = self.project.create_project(metadata = {"public": "false"}, **TestProjects.USER_add_rule_CLIENT) #2.2. Get private project of uesr-001, uesr-001 can see only one private project which is project-001 self.project.projects_should_exist(dict(public=False), expected_count = 1, expected_project_id = TestProjects.project_add_rule_id, **TestProjects.USER_add_rule_CLIENT) #3. Create a new registry TestProjects.registry_id, _ = self.registry.create_registry("https://" + harbor_server,**ADMIN_CLIENT) #4. Create a new rule for this registry; TestProjects.rule_id, rule_name = self.replication.create_replication_policy(dest_registry=v2_swagger_client.Registry(id=int(TestProjects.registry_id)), **ADMIN_CLIENT) #5. Check rule should be exist self.replication.check_replication_rule_should_exist(TestProjects.rule_id, rule_name, **ADMIN_CLIENT)