def test_do_unpackage_good_package(self): self.default_args = parse_args([]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = self.p._do_unpackage() self.assertIsNone(r.error)
def get(self, package_process_uuid): LOG.info("GET to /packages/status/ w. args: {}".format( package_process_uuid), extra={"start_stop": "START"}) p = PM.get_packager(package_process_uuid) if p is None: LOG.warning("GET to /packages/status/ done", extra={ "start_stop": "STOP", "status": 404 }) return { "error_msg": "Package process not found: {}".format(package_process_uuid) }, 404 LOG.info("GET to /packages/status/ done", extra={ "start_stop": "STOP", "status": p.status }) return { "package_process_uuid": str(p.uuid), "status": p.status, "error_msg": p.error_msg }
def test_autoversion(self): p = PM.new_packager(self.default_args, pkg_format="test") project_descriptors = [{"package": {"version": "1.0"}}, {"package": {"version": "1.0.3"}}, {"package": {"version": 1.5}}, {"package": {"version": "1"}}, {"package": {"version": 1}}, {"package": {"version": "."}}] project_descriptor_results = [{"package": {"version": "1.0.1"}}, {"package": {"version": "1.0.4"}}, {"package": {"version": "1.5.1"}}, {"package": {"version": "1.0.1"}}, {"package": {"version": "1.0.1"}}, {"package": {"version": "0.0.1"}}] for desc, result in zip(project_descriptors, project_descriptor_results): self.assertEqual(p.autoversion(desc), result) # incremented? self.assertTrue(p.version_incremented, msg=str(desc)+", "+str(result)) # Flag set? project_descriptors_invalid = [{"package": {"version": ""}}, {"package": {"version": "text"}}] for desc in project_descriptors_invalid: project_descriptor = p.autoversion(desc) self.assertEqual(project_descriptor, desc) # no changes if failed self.assertFalse(p.version_incremented, msg=str(desc))
def test_do_package_good_project(self): self.default_args = parse_args([]) self.default_args.package = misc_file("5gtango_ns_project_example1") self.default_args.output = os.path.join(tempfile.mkdtemp(), "test.tgo") p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = p._do_package() self.assertIsNone(r.error) # check structure of wd wd = r._project_wd self.assertTrue(os.path.exists(wd)) self.assertTrue(os.path.exists(os.path.join(wd, "TOSCA-Metadata"))) self.assertTrue(os.path.exists(os.path.join(wd, "Definitions"))) for pc in r.package_content: self.assertTrue( os.path.exists( os.path.join(wd, os.path.dirname(pc.get("source"))))) # check generated files for pc in r.package_content: self.assertTrue(os.path.exists(os.path.join(wd, pc.get("source")))) self.assertTrue( os.path.exists(os.path.join(wd, "TOSCA-Metadata/NAPD.yaml"))) self.assertTrue(os.path.exists(os.path.join(wd, "etsi_manifest.mf"))) self.assertTrue( os.path.exists(os.path.join(wd, "TOSCA-Metadata/TOSCA.meta"))) # check *.tgo file self.assertTrue(os.path.exists(self.default_args.output))
def test_store_autoversion(self): # Set up test tmp = NamedTemporaryFile() project_descriptor_path = "" project_descriptor_filename = tmp.name test_dict = {"test": "test"} f = open(project_descriptor_filename, "w") yaml.dump(test_dict, f, default_flow_style=False) f.close() p = PM.new_packager(self.default_args, pkg_format="test") project_descriptor = {"package": {"version": "1.0.1"}} # store to fail self.assertFalse(p.store_autoversion(project_descriptor, project_descriptor_path)) f = open(project_descriptor_filename, "r") result = yaml.load(f) f.close() self.assertEqual(result, test_dict) # succeful store p.version_incremented = True self.assertTrue(p.store_autoversion(project_descriptor, project_descriptor_path, project_descriptor_filename)) f = open(project_descriptor_filename, "r") result = yaml.load(f) f.close() self.assertEqual(result, project_descriptor)
def test_compress_subfolders(self): tmp_subfolders = [mkdtemp() for i in range(5)] tmp_files = [[NamedTemporaryFile(dir=tmp) for i in range(5)] for tmp in tmp_subfolders] file_descriptors = [{"path": tmp, "type": "application/vnd.folder.compressed.zip"} for tmp in tmp_subfolders] file_descriptors_not_subfolder = [{"path": "path/to", "type": "type"} for i in range(5)] project_descriptor = { "files": file_descriptors + file_descriptors_not_subfolder} p = PM.new_packager(self.default_args, pkg_format="test") p.compress_subfolders(project_descriptor, ".") for i, file in enumerate(project_descriptor["files"]): if file["type"] != "application/vnd.folder.compressed.zip": continue self.assertTrue(os.path.exists(file["_project_source"]), msg=os.listdir( os.path.dirname(file["_project_source"]))) self.assertTrue(os.path.isfile(file["_project_source"]), msg=os.listdir( os.path.dirname(file["_project_source"]))) self.assertEqual(os.path.splitext(file["_project_source"])[1], ".zip") with zipfile.ZipFile(file["_project_source"]) as zf: names = zf.namelist() for tmp_file in tmp_files[i]: self.assertIn(os.path.basename(tmp_file.name), names)
def test_on_packaging_done(self): args = MockArgs() p = PM.new_packager(args) p.result.metadata["_storage_location"] = "testdir/test.tgo" with app.test_request_context(): s = on_packaging_done(p) self.assertEqual(s, 200)
def post(self): LOG.warning("endpoint not implemented yet") args = projects_parser.parse_args() LOG.info("POST to /projects w. args: {}".format(args), extra={"start_stop": "START"}) args.package = None # fill with path to uploaded project args.unpackage = None # pass CLI args to REST args args.output = None args.workspace = None args.offline = False args.no_checksums = False args.no_autoversion = False if app.cliargs is not None: args.offline = app.cliargs.offline args.no_checksums = app.cliargs.no_checksums args.no_autoversion = app.cliargs.no_autoversion p = PM.new_packager(args) p.package(callback_func=on_packaging_done) LOG.info("POST to /projects done.", extra={ "start_stop": "START", "status": 501 }) return "not implemented", 501
def test_pack_packages(self): # prepare test args = parse_args(["--format", "eu.lf.onap"]) args.package = "" p = PM.new_packager(args, pkg_format=args.pkg_format) project_name = "project" wd = tempfile.mkdtemp() self.reset_tmp_files() package_set = self.create_test_OnapPackageSet(project_name) p.attach_files(package_set) p.pack_packages(wd, package_set) for package in package_set.packages(): package_path = os.path.join(wd, "{}.csar".format(package.package_name)) self.assertTrue(os.path.exists(package_path), msg=str((package_path, os.listdir(wd)))) for vnf in package_set.vnfds.values(): package_path = os.path.join(wd, "{}.csar".format(vnf.package_name)) with zipfile.ZipFile(package_path) as f: member_names = f.namelist() for folder in OnapPackageSet.folders: self.assertTrue( self.substring_in_list(folder, member_names)) file_members = list( map(lambda member: os.path.basename(member), member_names)) for file in vnf.package_content: filename = os.path.basename(file["filename"]) self.assertIn(filename, file_members)
def test_do_unpackage_bad_metadata(self): self.default_args = parse_args([]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example-malformed.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = self.p._do_unpackage() self.assertIsNotNone(r.error) self.assertIn("failed", r.error)
def test_do_unpackage_bad_checksum(self): self.default_args = parse_args([]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example-bad-checksum.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = self.p._do_unpackage() self.assertIsNotNone(r.error) self.assertIn("Checksum mismatch!", r.error)
def test_direct_call_package_direct_call_unpackage(self): # 1. package self.default_args = parse_args([]) self.default_args.package = misc_file("5gtango_ns_project_example1") self.default_args.output = os.path.join(tempfile.mkdtemp(), "test.tgo") pkg_path = self.default_args.output p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = p._do_package() self.assertIsNone(r.error) # check *.tgo file self.assertTrue(os.path.exists(self.default_args.output)) # 2. unpackage self.default_args = parse_args([]) self.default_args.unpackage = pkg_path self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = self.p._do_unpackage() self.assertIsNone(r.error)
def test_do_unpackage_bad_package(self): self.default_args = parse_args([]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example-bad.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = self.p._do_unpackage() self.assertIsNotNone(r.error) self.assertIn("tng-validate error", r.error)
def setUp(self): # we need a packager to setup a environment to work on self.default_args = parse_args(["-o", tempfile.mkdtemp()]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango", storage_backend=None)
def post(self, **kwargs): t_start = time.time() args = packages_parser.parse_args() LOG.info("POST to /packages w. args: {}".format(args), extra={"start_stop": "START"}) if args.package.filename is None: LOG.warning("Posted package filename was None.") args.package.filename = "temp_pkg.tgo" temppkg_path = _write_to_temp_file(args.package) args.package = None args.unpackage = temppkg_path # pass CLI args to REST args args.offline = False args.no_checksums = False args.no_autoversion = False args.store_skip = False if app.cliargs is not None: args.output = None args.workspace = None args.offline = app.cliargs.offline args.no_checksums = app.cliargs.no_checksums args.no_autoversion = app.cliargs.skip_autoversion args.store_skip = app.cliargs.store_skip args.skip_validation = app.cliargs.skip_validation # select and instantiate storage backend sb = None if (not args.store_skip # from CLI and not args.skip_store # from request and not os.environ.get("STORE_SKIP", "False") == "True"): sb_env = os.environ.get("STORE_BACKEND", "TangoCatalogBackend") if sb_env == "TangoCatalogBackend": sb = TangoCatalogBackend(args) elif sb_env == "TangoProjectFilesystemBackend": sb = TangoProjectFilesystemBackend(args) elif sb_env == "OsmNbiBackend": sb = OsmNbiBackend(args) else: LOG.warning("Unknown storage backend: {}.".format(sb_env)) # instantiate packager p = PM.new_packager(args, storage_backend=sb) try: p.unpackage(callback_func=on_unpackaging_done) except BaseException as e: LOG.exception("Unpackaging error: {}".format(e)) LOG.info("POST to /packages done", extra={ "start_stop": "STOP", "status": p.status, "time_elapsed": str(time.time() - t_start) }) return { "package_process_uuid": str(p.uuid), "status": p.status, "error_msg": p.error_msg }
def test_package_unpackage_with_subfolder_compression(self): self.default_args = parse_args([]) self.default_args.package = misc_file( "mixed-ns-project-subfolder-test") self.default_args.output = os.path.join(tempfile.mkdtemp(), "test.tgo") pkg_path = self.default_args.output p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = p._do_package() self.assertIsNone(r.error) # check *.tgo file self.assertTrue(os.path.exists(self.default_args.output)) pp = misc_file("mixed-ns-project-subfolder-test") subfolder_files = os.path.join(pp, "subfolder") subfolder_files = get_files(subfolder_files) tmp = tempfile.mkdtemp() with zipfile.ZipFile(pkg_path) as zf: zf.extract("subfolder.zip", path=tmp) with zipfile.ZipFile(os.path.join(tmp, "subfolder.zip")) as zf: names = zf.namelist() names = [os.path.basename(file) for file in names] for file in subfolder_files: self.assertIn(file, names) self.default_args = parse_args([]) self.default_args.unpackage = pkg_path self.default_args.output = tempfile.mkdtemp() self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango", storage_backend=TangoProjectFilesystemBackend( self.default_args)) r = self.p._do_unpackage() storage_location = r.metadata.get("_storage_location") self.assertIsNone(r.error) self.assertTrue(os.path.exists(storage_location), msg=storage_location) self.assertTrue(os.path.exists( os.path.join(storage_location, "subfolder")), msg=os.listdir(storage_location)) self.assertTrue( os.path.isdir(os.path.join(storage_location, "subfolder"))) names = get_files(os.path.join(storage_location, "subfolder")) for file in subfolder_files: self.assertIn(file, names)
def test_do_package_good_project_with_autoversion(self): # set up test self.default_args = parse_args([]) tmpdir = tempfile.mkdtemp() tmp_project = os.path.join(tmpdir, "5gtango_ns_project_example1") tmp_project = copytree(misc_file("5gtango_ns_project_example1"), tmp_project) self.default_args.package = tmp_project self.default_args.output = os.path.join(tmpdir, "test.tgo") self.default_args.autoversion = True with open(os.path.join(self.default_args.package, "project.yml"), "r") as f: old_diction = yaml.load(f) old_version = LooseVersionExtended(old_diction["package"]["version"]) p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = p._do_package() autoversioned = p.autoversion(old_diction) self.assertIsNone(r.error) # check structure of wd wd = r._project_wd self.assertTrue(os.path.exists(wd)) self.assertTrue(os.path.exists(os.path.join(wd, "TOSCA-Metadata"))) # check NAPD.yaml self.assertTrue( os.path.exists(os.path.join(wd, "TOSCA-Metadata/NAPD.yaml"))) with open(os.path.join(wd, "TOSCA-Metadata/NAPD.yaml")) as f: new_diction = yaml.load(f) self.assertTrue( LooseVersionExtended(new_diction["version"]) > old_version) self.assertEqual(new_diction["version"], autoversioned["package"]["version"]) # check etsi self.assertTrue(os.path.exists(os.path.join(wd, "etsi_manifest.mf"))) with open(os.path.join(wd, "etsi_manifest.mf"), "r") as f: new_diction = yaml.load(f) self.assertTrue( LooseVersionExtended(new_diction["ns_package_version"]) > old_version) self.assertEqual(new_diction["ns_package_version"], autoversioned["package"]["version"]) # check *.tgo file self.assertTrue(os.path.exists(self.default_args.output)) # check source file with open(os.path.join(self.default_args.package, "project.yml"), "r") as f: new_project_descriptor = yaml.load(f) self.assertEqual(new_project_descriptor, autoversioned) self.assertTrue( LooseVersionExtended(new_project_descriptor["package"]["version"]) > old_version)
def test_unpackage_async(self): lock = threading.Semaphore() lock.acquire() def cb(args): lock.release() p = PM.new_packager(self.default_args, pkg_format="test") p.unpackage(callback_func=cb) self.assertTrue(lock.acquire(timeout=3.0), msg="callback was not called before timeout")
def setUp(self): # configure mocks self.patcher = patch("requests.post", mock_requests_post) # we need a packager to setup a environment to work on self.default_args = parse_args([]) self.default_args.unpackage = misc_file( "5gtango-ns-package-example.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango", storage_backend=None) # patch the requests lib to not do real requests self.patcher.start()
def get(self, package_process_uuid): p = PM.get_packager(package_process_uuid) if p is None: return { "error_msg": "Package process not found: {}".format(package_process_uuid) }, 404 return { "package_process_uuid": str(p.uuid), "status": p.status, "error_msg": p.error_msg }
def test_do_package_bad_project(self): self.default_args = parse_args([]) self.default_args.package = misc_file( "5gtango_ns_project_example1_bad") self.default_args.output = os.path.join(tempfile.mkdtemp(), "test.tgo") p = PM.new_packager(self.default_args, pkg_format="eu.5gtango") r = p._do_package() self.assertIsNotNone(r.error) self.assertIn("tng-validate error", r.error) # self.assertIn( # "Failed to read service function descriptors", r.error) # check *.tgo file self.assertFalse(os.path.exists(self.default_args.output))
def test_do_package(self): # prepare test project = misc_file("mixed-ns-project") output = tempfile.mkdtemp() args = parse_args( ["--format", "eu.lf.onap", "-p", project, "-o", output]) p = PM.new_packager(args, pkg_format=args.pkg_format) # execute p._do_package() packages = os.listdir(output) self.assertEqual(len(packages), 2) for package in packages: self.assertEqual(os.path.splitext(package)[1], ".csar") self.assertTrue(self.substring_in_list("onap_nsd", packages), msg="onap_nsd not as substr in {}".format(packages)) self.assertTrue(self.substring_in_list("onap_vnfd", packages), msg="onap_vnfd not as substr in {}".format(packages)) with open(os.path.join(project, "project.yml")) as f: pd = yaml.load(f) files = pd["files"] files = [ os.path.basename(file["path"]) for file in files if "onap" in file["type"] or "lf.onap" in file["tags"] ] nsd = None vnfd = None for file in files: if "nsd" in file: nsd = file if "vnfd" in file: vnfd = file files.remove(nsd) files.remove(vnfd) for package in packages: with zipfile.ZipFile(os.path.join(output, package)) as zf: names = zf.namelist() for file in files: self.assertTrue(self.substring_in_list(file, names), msg="{} not in {}".format(file, names)) if "nsd" in package: self.assertIn(nsd, names) self.assertIn(os.path.splitext(nsd)[0] + ".mf", names) if "vnfd" in package: self.assertIn(vnfd, names) self.assertIn(os.path.splitext(vnfd)[0] + ".mf", names) self.assertIn(os.path.join("TOSCA-Metadata", "TOSCA.meta"), names)
def dispatch(args): # trigger pack/unpack if args.package: # instantiate packager p = PM.new_packager(args, pkg_format=args.pkg_format) p.package() LOG.debug("Packager result: {}".format(p.result)) display_result_package(args, p.result) elif args.unpackage: # select and instantiate storage backend # default in CLI mode: TangoProjectFilesystemBackend sb = None if (not args.store_skip and not os.environ.get("STORE_SKIP", "False") == "True"): sb_env = args.store_backend if sb_env is None: sb_env = os.environ.get("STORE_BACKEND", "TangoProjectFilesystemBackend") if sb_env == "TangoCatalogBackend": sb = TangoCatalogBackend(args) elif sb_env == "TangoProjectFilesystemBackend": sb = TangoProjectFilesystemBackend(args) elif sb_env == "OsmNbiBackend": sb = OsmNbiBackend(args) else: LOG.warning( "Unknown storage backend: {}. Stop.".format(sb_env)) exit(1) # instantiate packager p = PM.new_packager(args, storage_backend=sb) p.unpackage() LOG.debug("Packager result: {}".format(p.result)) display_result_unpackage(args, p.result) else: print("Missing arguments. Type tng-package -h.") exit(1) return p.result
def test_zip_subfolder(self): tmp = mkdtemp() tmp_files = [NamedTemporaryFile(dir=tmp) for i in range(5)] file_descriptor = {"path": tmp} p = PM.new_packager(self.default_args, pkg_format="test") dest = p.zip_subfolder(pp=".", **file_descriptor) self.assertTrue(os.path.isfile(dest)) self.assertEqual(os.path.splitext(dest)[1], ".zip") with zipfile.ZipFile(dest) as zf: names = zf.namelist() for file in tmp_files: self.assertIn(os.path.basename(file.name), names)
def test_store_idempotent(self): self.default_args = parse_args(["-o", tempfile.mkdtemp()]) self.default_args.unpackage = misc_file( "eu.5gtango.idempotency_test.0.1.tgo") self.p = PM.new_packager(self.default_args, pkg_format="eu.5gtango", storage_backend=None) tpb = TangoProjectFilesystemBackend(self.default_args) napdr = self.p._do_unpackage() wd = napdr.metadata.get("_napd_path").replace( "/TOSCA-Metadata/NAPD.yaml", "") # call store using active working dir new_napdr = tpb.store(napdr, wd, self.default_args.unpackage) # check result self.assertIsNotNone(new_napdr.metadata.get("_storage_location")) sl = new_napdr.metadata.get("_storage_location") # check created project pd = self.default_args.output self.assertTrue(os.path.exists(pd)) self.assertTrue( os.path.exists( os.path.join(pd, "eu.5gtango.idempotency_test.0.1/project.yml"))) self.assertTrue(os.path.exists(os.path.join(sl, "project.yml"))) # files in root dir self.assertTrue(os.path.exists(os.path.join(sl, "vnfd-a10-3.yml"))) self.assertTrue(os.path.exists(os.path.join(sl, "vnfd-nginx-3.yml"))) # files in sources/ self.assertTrue(os.path.exists(os.path.join(sl, "sources/"))) self.assertTrue( os.path.exists(os.path.join(sl, "sources/vnfd-a10-4.yml"))) self.assertTrue( os.path.exists(os.path.join(sl, "sources/vnfd-nginx-4.yml"))) # files in sources/[...]/ self.assertTrue(os.path.exists(os.path.join(sl, "sources/nsd/nsd.yml"))) self.assertTrue( os.path.exists(os.path.join(sl, "sources/vnfd/vnfd-a10.yml"))) self.assertTrue( os.path.exists(os.path.join(sl, "sources/vnfd/vnfd-nginx.yml"))) # files in other folders of root dir self.assertTrue(os.path.exists(os.path.join(sl, "Definitions/"))) self.assertTrue( os.path.exists(os.path.join(sl, "Definitions/vnfd-a10-2.yml"))) self.assertTrue( os.path.exists(os.path.join(sl, "Definitions/vnfd-nginx-2.yml"))) shutil.rmtree(pd)
def test_attach_files(self): args = parse_args(["--format", "eu.etsi.osm"]) args.package = "" p = PM.new_packager(args, pkg_format=args.pkg_format) project_name = "project" self.reset_tmp_files() package_set = self.create_test_OsmPackageSet(project_name) p.attach_files(package_set) for package in package_set.packages(): for file in package.package_content: self.assertTrue( os.path.exists( os.path.join(package.temp_dir, file["source"], file["filename"])))
def test_create_temp_dir(self): # prepare test args = parse_args(["--format", "eu.etsi.osm"]) p = PM.new_packager(args, pkg_format=args.pkg_format) tmp_descriptor = tempfile.NamedTemporaryFile() kwargs = { "subdir_name": "name", "descriptor": tmp_descriptor.name, "hash": "hash_value", "folders": OsmPackager.folders_nsd, "project_path": "", "checks_filename": "checksums.txt" } # execute temp = p.create_temp_dir(**kwargs) # check results self.assertIsInstance(temp, str) # got path self.assertTrue(os.path.exists(temp)) # created directory exists for folder in OsmPackager.folders_nsd + [tmp_descriptor.name]: # folders created ? self.assertTrue(os.path.exists(os.path.join(temp, folder)), msg=os.path.join(temp, folder)) # new descriptor file for next test tmp_descriptor.close() del tmp_descriptor tmp_descriptor = tempfile.NamedTemporaryFile() kwargs["descriptor"] = tmp_descriptor.name kwargs["folders"] = OsmPackager.folders_vnf # vnf dir-tree this time # execute temp = p.create_temp_dir(**kwargs) self.assertIsInstance(temp, str) self.assertTrue(os.path.exists(temp)) for folder in OsmPackager.folders_vnf + [tmp_descriptor.name]: self.assertTrue(os.path.exists(os.path.join(temp, folder)), msg=os.path.join(temp, folder)) tmp_descriptor.close() del tmp_descriptor
def test_do_package(self): # prepare test project = misc_file("mixed-ns-project") output = tempfile.mkdtemp() args = parse_args( ["--format", "eu.etsi.osm", "-p", project, "-o", output]) p = PM.new_packager(args, pkg_format=args.pkg_format) # execute napdr = p._do_package() # checks self.assertIsNone(napdr.error) packages = os.listdir(output) basename = os.path.basename(output) basename_ns = "_".join([basename, "osm_nsd"]) basename_vnf = "_".join([basename, "osm_vnfd"]) filename_ns = basename_ns + ".tar.gz" filename_vnf = basename_vnf + ".tar.gz" self.assertIn(filename_ns, packages) self.assertIn(filename_vnf, packages) ns = [ "osm_nsd.yaml", "checksums.txt", "icons/upb_logo.png", "vnf_config", "scripts", "ns_config", "icons" ] vnf = [ "osm_vnfd.yaml", "checksums.txt", "scripts", "images", "icons", "cloud_init", "charms", "icons/upb_logo.png", "cloud_init/cloud.init", "images/mycloudimage.ref" ] for package in packages: with tarfile.open(os.path.join(output, package)) as f: member_names = list( map(lambda member: member.name, f.getmembers())) if "ns" in package: for member in ns: self.assertIn(os.path.join(basename_ns, member), member_names) elif "vnf" in package: for member in vnf: self.assertIn(os.path.join(basename_vnf, member), member_names)
def test_create_temp_dirs(self): # prepare test args = parse_args(["--format", "eu.etsi.osm"]) args.package = "" p = PM.new_packager(args, pkg_format=args.pkg_format) project_name = "test" tmp_descriptor = tempfile.NamedTemporaryFile() package_set = OsmPackagesSet(NapdRecord()) # ns descriptor package_set.nsd = OsmPackage( { "_project_source": tmp_descriptor.name, "hash": "hash_value", "filename": tmp_descriptor.name }, project_name=project_name, folders=OsmPackagesSet.folders_nsd) # 5 vnf descriptors vnf_num = 5 tmps = [tempfile.NamedTemporaryFile() for i in range(vnf_num)] package_set.vnfds = { tmp_descriptor.name: OsmPackage( { "_project_source": tmp_descriptor.name, "hash": "hash_value" + str(i), "filename": tmp_descriptor.name }, project_name=project_name, folders=OsmPackagesSet.folders_vnf) for i, tmp_descriptor in zip(range(vnf_num), tmps) } # execute p.create_temp_dirs(package_set, project_path="") # check if directories created for package in package_set.packages(): self.assertTrue(os.path.exists(package.temp_dir), msg=str(package))
def test_do_package_subfolder(self): # prepare test project = misc_file("mixed-ns-project-subfolder-test") output = tempfile.mkdtemp() args = parse_args( ["--format", "eu.etsi.osm", "-p", project, "-o", output]) p = PM.new_packager(args, pkg_format=args.pkg_format) # execute napdr = p._do_package() self.assertIsNone(napdr.error) packages = os.listdir(output) subfolder_files = get_files(os.path.join(project, "subfolder")) for package in packages: with tarfile.open(os.path.join(output, package)) as f: member_names = list( map(lambda member: os.path.basename(member.name), f.getmembers())) for file in subfolder_files: self.assertIn(file, member_names)