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 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_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_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 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_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 *.tgo file
self.assertTrue(os.path.exists(self.default_args.output))
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 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 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 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_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_project_package_project(self):
# create package
f = open(misc_file("5gtango_ns_a10_nginx_zipped_project_example.zip"),
"rb")
project = FileStorage(f)
r = self.app.post("/api/v1/projects",
content_type="multipart/form-data",
data={
"project": project,
"callback_url": "https://test.local:8000/cb",
"skip_store": True
})
self.assertEqual(r.status_code, 200)
f.close()
# download created package
r = self.app.get("api/v1/projects")
self.assertEqual(r.status_code, 200)
r = json.loads(r.get_data(as_text=True))
self.assertIsInstance(r, list)
self.assertIsInstance(r[0], dict)
self.assertIn("package_name", r[0])
self.assertIn("package_download_link", r[0])
r = self.app.get(r[0]["package_download_link"])
self.assertEqual(r.status_code, 200)
data = r.get_data()
tmp = tempfile.mkdtemp()
filename = "name.tgo"
path = os.path.join(tmp, filename)
with open(path, "wb") as f:
f.write(data)
# do a post with a real package and callback_url
r = self.app.post("/api/v1/packages",
content_type="multipart/form-data",
data={
"package": open(path, "rb"),
"skip_store": True
})
self.assertEqual(r.status_code, 200)
rd = json.loads(r.get_data(as_text=True))
self.assertIn("package_process_uuid", rd)
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)
def test_project_v1_endpoint(self):
# do a malformed post
r = self.app.post("/api/v1/projects",
content_type="multipart/form-data",
data={
"project":
(None, "5gtango-ns-project-example.zip"),
"callback_url": "https://test.local:8000/cb",
"skip_store": True
})
self.assertEqual(r.status_code, 500)
# do a acceptable post
f = open(misc_file("5gtango_ns_a10_nginx_zipped_project_example.zip"),
"rb")
project = FileStorage(f)
r = self.app.post("/api/v1/projects",
content_type="multipart/form-data",
data={
"project": project,
"callback_url": "https://test.local:8000/cb",
"skip_store": True
})
self.assertEqual(r.status_code, 200)
f.close()
