mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
a1f825e7c7
This PR prepares marvin and tests for python3. it was part of #4479, until nose2 was decided to be abandoned from that PR. Re-PR of #4543 and #3730 to enable cooperation Co-authored-by: Daan Hoogland <dahn@onecht.net> Co-authored-by: Gabriel Beims Bräscher <gabriel@apache.org> Co-authored-by: Rohit Yadav <rohit.yadav@shapeblue.com>
1457 lines
52 KiB
Python
1457 lines
52 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
""" P1 tests for Dedicating Public IP addresses
|
|
|
|
Test Plan: https://cwiki.apache.org/confluence/display/CLOUDSTACK/
|
|
Dedicated+Resources+-+Public+IP+Addresses+and+VLANs+per+Tenant+Test+Plan
|
|
|
|
Issue Link: https://issues.apache.org/jira/browse/CLOUDSTACK-2251
|
|
|
|
Feature Specifications: https://cwiki.apache.org/confluence/display/
|
|
CLOUDSTACK/FS-+Dedicate+Public+IP+Addresses+per+tenant
|
|
"""
|
|
# Import Local Modules
|
|
from nose.plugins.attrib import attr
|
|
from marvin.cloudstackTestCase import cloudstackTestCase
|
|
import unittest
|
|
from marvin.lib.utils import (validateList,
|
|
cleanup_resources,
|
|
random_gen)
|
|
from marvin.lib.base import (Account,
|
|
PublicIpRange,
|
|
Domain,
|
|
Network,
|
|
NetworkOffering,
|
|
PublicIPAddress,
|
|
VPC,
|
|
VpcOffering,
|
|
LoadBalancerRule,
|
|
Resources)
|
|
from marvin.lib.common import (get_domain,
|
|
get_zone,
|
|
get_free_vlan)
|
|
from marvin.codes import PASS
|
|
from netaddr import IPAddress
|
|
import random
|
|
|
|
|
|
class TestDedicatePublicIPRange(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(
|
|
TestDedicatePublicIPRange,
|
|
cls).getClsTestClient()
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.testdata = cls.testClient.getParsedTestDataConfig()
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
# Get Zone, Domain
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.testdata["isolated_network"]["zoneid"] = cls.zone.id
|
|
cls.testdata["publiciprange"]["zoneid"] = cls.zone.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.isolated_network_offering = NetworkOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_network_offering.update(
|
|
cls.apiclient,
|
|
state='Enabled')
|
|
|
|
cls.vpc_network_offering = NetworkOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["nw_offering_isolated_vpc"],
|
|
conservemode=False)
|
|
cls._cleanup.append(cls.vpc_network_offering)
|
|
cls.vpc_network_offering.update(cls.apiclient, state='Enabled')
|
|
|
|
cls.vpc_off = VpcOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["vpc_offering"]
|
|
)
|
|
cls.vpc_off.update(cls.apiclient, state='Enabled')
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest(e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.apiclient, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
|
|
# Setting up random public ip range
|
|
self.testdata["publiciprange"]["vlan"] = get_free_vlan(
|
|
self.apiclient,
|
|
self.zone.id)[1]
|
|
random_subnet_number = random.randrange(1, 254)
|
|
self.testdata["publiciprange"]["gateway"] = "172.16." + \
|
|
str(random_subnet_number) + ".1"
|
|
self.testdata["publiciprange"]["startip"] = "172.16." + \
|
|
str(random_subnet_number) + ".2"
|
|
self.testdata["publiciprange"]["endip"] = "172.16." + \
|
|
str(random_subnet_number) + ".3"
|
|
self.testdata["publiciprange"]["netmask"] = "255.255.255.0"
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_01_dedicate_public_ip_range_root_domain(self):
|
|
"""Dedicate public IP range to an account in root domain
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range
|
|
# 2. Created IP range should be present, verify with listVlanIpRanges
|
|
# 3. Dedicate the created IP range to user account
|
|
# 4. Verify IP range is dedicated, verify with listVlanIpRanges
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(
|
|
validateList(public_ip_ranges)[0],
|
|
PASS,
|
|
"public ip ranges list validation failed"
|
|
)
|
|
self.assertEqual(
|
|
public_ip_ranges[0].id,
|
|
public_ip_range.vlan.id,
|
|
"Check public ip range response id is in listVlanIpRanges"
|
|
)
|
|
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_02_dedicate_public_ip_range_user_domain(self):
|
|
"""Dedicate public IP range to an account in user domain
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range
|
|
# 2. Created IP range should be present, verify with listVlanIpRanges
|
|
# 3. Dedicate the created IP range to user account
|
|
# 4. Verify IP range is dedicated, verify with listVlanIpRanges
|
|
# 5. Release the dedicated Public IP range back to the system
|
|
# 6. Verify IP range has been released, verify with listVlanIpRanges
|
|
# 7. Delete the Public IP range"""
|
|
|
|
user_domain = Domain.create(
|
|
self.apiclient,
|
|
services=self.testdata["domain"],
|
|
parentdomainid=self.domain.id)
|
|
self.cleanup.append(user_domain)
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(
|
|
validateList(public_ip_ranges)[0],
|
|
PASS,
|
|
"public ip ranges list validation failed"
|
|
)
|
|
self.assertEqual(
|
|
public_ip_ranges[0].id,
|
|
public_ip_range.vlan.id,
|
|
"Check public ip range response id is in listVlanIpRanges"
|
|
)
|
|
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_03_dedicate_during_creation_root_domain(self):
|
|
"""Dedicate public IP range to an account during its creation only
|
|
|
|
# Validate the following:
|
|
# 1. Create an account in root domain
|
|
# 2. Create a public IP range and pass account name and domain id
|
|
while creating
|
|
# 3. The public IP range should be successfully added and it should
|
|
be dedicated to the account
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"],
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(
|
|
validateList(public_ip_ranges)[0],
|
|
PASS,
|
|
"public ip ranges list validation failed"
|
|
)
|
|
self.assertEqual(
|
|
public_ip_ranges[0].id,
|
|
public_ip_range.vlan.id,
|
|
"Check public ip range response id is in listVlanIpRanges"
|
|
)
|
|
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_04_dedicate_during_creation_user_domain(self):
|
|
"""Dedicate public IP range to an account in user
|
|
domain during its creation only
|
|
|
|
# Validate the following:
|
|
# 1. Create a user domain and an account in it
|
|
# 2. Create a public IP range and pass account name
|
|
and domain id while creating
|
|
# 3. The public IP range should be successfully added
|
|
and it should be dedicated to the account
|
|
"""
|
|
|
|
user_domain = Domain.create(
|
|
self.apiclient,
|
|
services=self.testdata["domain"],
|
|
parentdomainid=self.domain.id)
|
|
self.cleanup.append(user_domain)
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"],
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(
|
|
validateList(public_ip_ranges)[0],
|
|
PASS,
|
|
"public ip ranges list validation failed"
|
|
)
|
|
self.assertEqual(
|
|
public_ip_ranges[0].id,
|
|
public_ip_range.vlan.id,
|
|
"Check public ip range response id is in listVlanIpRanges"
|
|
)
|
|
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_05_acquire_ip_single_guest_network(self):
|
|
"""Create guest network in account with dedicated public
|
|
ip range and acquire IPs in network
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range with 2 IPs in it
|
|
# 2. Dedicate the created IP range to user account
|
|
# 3. Create a guest network in the account
|
|
# 4. Acquire a public IP for this network
|
|
# 5. Verify that the acquired IP is from the dedicated range
|
|
# 6. Repeat steps 4 and 5 so that both the IPs in the range are
|
|
now acquired
|
|
# 7. Repeat step 4
|
|
# 8. Now this public IP should not be from the dedicated range,
|
|
it should be from global pool
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
# Format the IP so that it can be used to compare with other IPs
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip2 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip2.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip3 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip3.ipaddress.ipaddress)
|
|
|
|
self.assertFalse(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should not be from the dedicated range")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_06_acquire_ip_multiple_guest_network(self):
|
|
"""Create multiple guest networks and acquire IPs from dedicated range
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range with 2 IPs in it
|
|
# 2. Dedicate the created IP range to user account
|
|
# 3. Create a guest network in the account
|
|
# 4. Acquire a public IP for this network
|
|
# 5. Verify that the acquired IP is from the dedicated range
|
|
# 6. Repeat steps 3,4 and 5 so that both the IPs in the range are
|
|
now acquired
|
|
# 7. Repeat step 4 for network 1
|
|
# 8. Now this public IP should not be from the dedicated range,
|
|
it should be from global pool
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
|
|
isolated_network1 = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network1.id)
|
|
|
|
formatted_publicip1 = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip1) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
isolated_network2 = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
public_ip2 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network2.id)
|
|
|
|
formatted_publicip2 = IPAddress(public_ip2.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip2) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip3 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network1.id)
|
|
|
|
formatted_publicip3 = IPAddress(public_ip3.ipaddress.ipaddress)
|
|
|
|
self.assertFalse(int(formatted_startip) <=
|
|
int(formatted_publicip3) <= int(formatted_endip),
|
|
"publicip should not be from the dedicated range")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_08_acquire_ip_in_vpc(self):
|
|
"""Acquire public IP from dedicated range in network tier of VPC
|
|
|
|
# Validate the following:
|
|
# 1. Create a domain and an account in it
|
|
# 2. Create a VPC in this account
|
|
# 3. Create a netwok tier in this VPC
|
|
# 4. Create a Public IP range and dedicate to account
|
|
# 5. Dedicate the created IP range to user account
|
|
# 6. Acquire public IP in the network tier of VPC
|
|
# 7. Ip should be from the dedicated range
|
|
# 8. Repeat steps 6 and 7
|
|
# 9. Repeat step 6, this time the IP should not be from
|
|
dedicated range, it should be from global pool
|
|
"""
|
|
if self.hypervisor.lower() in ["hyperv"]:
|
|
self.skipTest("Skipping test as VPC is not supported on HyperV")
|
|
user_domain = Domain.create(
|
|
self.apiclient,
|
|
services=self.testdata["domain"],
|
|
parentdomainid=self.domain.id)
|
|
self.cleanup.append(user_domain)
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account)
|
|
self.testdata["vpc"]["cidr"] = '10.1.1.0/16'
|
|
vpc = VPC.create(
|
|
self.apiclient,
|
|
self.testdata["vpc"],
|
|
vpcofferingid=self.vpc_off.id,
|
|
zoneid=self.zone.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["network"],
|
|
accountid=account.name,
|
|
domainid=account.domainid,
|
|
networkofferingid=self.vpc_network_offering.id,
|
|
zoneid=self.zone.id,
|
|
gateway='10.1.1.1',
|
|
netmask='255.255.255.0',
|
|
vpcid=vpc.id
|
|
)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
networkid=network.id,
|
|
accountid=account.name,
|
|
domainid=account.domainid,
|
|
vpcid=vpc.id)
|
|
|
|
formatted_publicip1 = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip1) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip2 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
networkid=network.id,
|
|
accountid=account.name,
|
|
domainid=account.domainid,
|
|
vpcid=vpc.id)
|
|
|
|
formatted_publicip2 = IPAddress(public_ip2.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip2) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip3 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
networkid=network.id,
|
|
accountid=account.name,
|
|
domainid=account.domainid,
|
|
vpcid=vpc.id)
|
|
|
|
formatted_publicip3 = IPAddress(public_ip3.ipaddress.ipaddress)
|
|
|
|
self.assertFalse(int(formatted_startip) <=
|
|
int(formatted_publicip3) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
return
|
|
|
|
|
|
class TestFailureScenarios(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestFailureScenarios, cls).getClsTestClient()
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.testdata = cls.testClient.getParsedTestDataConfig()
|
|
# Get Zone, Domain
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.testdata["isolated_network"]["zoneid"] = cls.zone.id
|
|
cls.testdata["publiciprange"]["zoneid"] = cls.zone.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.isolated_network_offering = NetworkOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_network_offering.update(
|
|
cls.apiclient,
|
|
state='Enabled')
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest(e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.apiclient, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
|
|
# Setting up random public ip range
|
|
self.testdata["publiciprange"]["vlan"] = get_free_vlan(
|
|
self.apiclient,
|
|
self.zone.id)[1]
|
|
subnet_number = random.randrange(1, 254)
|
|
self.testdata["publiciprange"][
|
|
"gateway"] = "172.16." + str(subnet_number) + ".1"
|
|
self.testdata["publiciprange"][
|
|
"startip"] = "172.16." + str(subnet_number) + ".2"
|
|
self.testdata["publiciprange"][
|
|
"endip"] = "172.16." + str(subnet_number) + ".3"
|
|
self.testdata["publiciprange"]["netmask"] = "255.255.255.0"
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_10_dedicate_invalid_ip_range(self):
|
|
"""Dedicate invalid public IP range to an account
|
|
|
|
# Validate the following:
|
|
# 1. Create an account in root domain
|
|
# 2. Create a Public IP range by giving invalid ip addresses
|
|
and specify the account name and domain id while creating
|
|
# 3. The operations should fail
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
# Specify invalid IPs
|
|
self.testdata["publiciprange"]["startip"] = "172.16.255.256"
|
|
self.testdata["publiciprange"]["startip"] = "172.16.255.257"
|
|
self.testdata["publiciprange"]["gateway"] = "172.16.255.1"
|
|
|
|
with self.assertRaises(Exception):
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"],
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_11_dedicate_to_wrong_account(self):
|
|
"""Dedicate public IP range to invalid account
|
|
|
|
# Validate the following:
|
|
# 1. Create an account in root domain
|
|
# 2. Create a Public IP range with valid ip addresses
|
|
and specify invalid account name and domain id while creating
|
|
# 3. The operation should fail
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
with self.assertRaises(Exception):
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"],
|
|
account=account.name + random_gen(),
|
|
domainid=account.domainid
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_12_dedicate_already_dedicated_range(self):
|
|
"""Dedicate already dedicated public IP range
|
|
|
|
# Validate the following:
|
|
# 1. Create a user domain and two accounts in it
|
|
# 2. Create a Public IP range
|
|
# 3. Dedicate the created IP range to account1
|
|
# 4. Try to dedicate the same public iprage to account 2
|
|
# 5. The operation should fail"""
|
|
|
|
user_domain = Domain.create(
|
|
self.apiclient,
|
|
services=self.testdata["domain"],
|
|
parentdomainid=self.domain.id)
|
|
self.cleanup.append(user_domain)
|
|
|
|
account1 = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account1)
|
|
|
|
account2 = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account2)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account1.name,
|
|
domainid=account1.domainid
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account2.name,
|
|
domainid=account2.domainid
|
|
)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_13_public_ips_limit(self):
|
|
"""Dedicate public IP range to an account having lesser public
|
|
ip limit than range
|
|
|
|
# Validate the following:
|
|
# 1. Create a user domain and account
|
|
# 2. Set the public IP limit of account to 1
|
|
# 3. Create a Public IP range of 2 IPs
|
|
# 4. Try to dedicate the range to account
|
|
# 5. Operation should fail as it exceeds the account limit
|
|
"""
|
|
|
|
user_domain = Domain.create(
|
|
self.apiclient,
|
|
services=self.testdata["domain"],
|
|
parentdomainid=self.domain.id)
|
|
self.cleanup.append(user_domain)
|
|
|
|
account1 = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=user_domain.id
|
|
)
|
|
self.cleanup.insert(-1, account1)
|
|
|
|
# Updating maximum public ips limit of account to 1
|
|
Resources.updateLimit(self.apiclient,
|
|
resourcetype=1,
|
|
max=1,
|
|
account=account1.name,
|
|
domainid=account1.domainid)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
# public ip range consists of 2 ips, hence dedication should fail
|
|
with self.assertRaises(Exception):
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account1.name,
|
|
domainid=account1.domainid
|
|
)
|
|
return
|
|
|
|
|
|
class TestReleaseIPs(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestReleaseIPs, cls).getClsTestClient()
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.testdata = cls.testClient.getParsedTestDataConfig()
|
|
# Get Zone, Domain
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.testdata["isolated_network"]["zoneid"] = cls.zone.id
|
|
cls.testdata["publiciprange"]["zoneid"] = cls.zone.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.isolated_network_offering = NetworkOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_network_offering.update(
|
|
cls.apiclient,
|
|
state='Enabled')
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest(e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.apiclient, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
|
|
# Setting up random public ip range
|
|
self.testdata["publiciprange"]["vlan"] = get_free_vlan(
|
|
self.apiclient,
|
|
self.zone.id)[1]
|
|
shared_network_subnet_number = random.randrange(1, 254)
|
|
self.testdata["publiciprange"]["gateway"] = "172.16." + \
|
|
str(shared_network_subnet_number) + ".1"
|
|
self.testdata["publiciprange"]["startip"] = "172.16." + \
|
|
str(shared_network_subnet_number) + ".2"
|
|
self.testdata["publiciprange"]["endip"] = "172.16." + \
|
|
str(shared_network_subnet_number) + ".3"
|
|
self.testdata["publiciprange"]["netmask"] = "255.255.255.0"
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_14_release_ip_from_dedicated_range(self):
|
|
"""Disassociate a public IP from dedicated public IP range
|
|
|
|
# Validate the following:
|
|
# 1. Create an account in root domain
|
|
# 2. Create a guest network in the account
|
|
# 3. Acquire a public IP from global pool in this network
|
|
for source nat purpose
|
|
# 4. Create a public IP range
|
|
# 5. Dedicate this range to the account
|
|
# 6. Acquire public IP for the guest network
|
|
# 7. Verify that the public IP is from the dedicate range
|
|
# 8. Disassociate the public IP, the operation should be successful
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
# Acquiring IP for source nat purposes
|
|
PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip1.delete(self.apiclient)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_15_release_dedicated_range(self):
|
|
"""Release dedicated public ip range with no IPs acquired
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range in an account
|
|
# 2. Dedicate the created IP range to user account
|
|
# 3. Verify IP range is dedicated, verify with listVlanIpRanges
|
|
# 4. Release the public IP range, verify that it is released
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
|
|
public_ip_range.release(self.apiclient)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
str(public_ip_ranges[0].account).lower(),
|
|
"system",
|
|
"Check account name is system")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_21_release_dedicated_range_ip_address_in_use(self):
|
|
"""Dedicate a public IP range, acquire some IPs and relese the range
|
|
|
|
# Validate the following:
|
|
# 1. Create an account
|
|
# 2. Create a guest network in the account
|
|
# 3. Create a Public IP range in an account
|
|
# 4. Dedicate the created IP range to user account
|
|
# 5. Acquire IP in the network and verify that it is from dedicated
|
|
range
|
|
# 6. Release the public IP range, verify that it is released
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
# Format the IP so that it can be used to compare with other IPs
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip_range.release(self.apiclient)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
str(public_ip_ranges[0].account).lower(),
|
|
"system",
|
|
"Check account name is system")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_16_delete_ip_range_no_network_rules(self):
|
|
"""Delete dedicated public IP range with no network rules on IP addresses
|
|
|
|
# Validate the following:
|
|
# 1. Create account in root domain
|
|
# 2. Create guest network in it
|
|
# 3. Create a Public IP range
|
|
# 4. Dedicate the created IP range to user account
|
|
# 5. Acquire public IP in guest network
|
|
# 6. Verify that IP address in from dedicated range
|
|
# 7. Delete the dedicated public IP range
|
|
# 8. The operation should be successful
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
# Acquiring ip for source nat purposes
|
|
PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
public_ip_range.delete(self.apiclient)
|
|
self.cleanup.remove(public_ip_range)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_17_delete_ip_range_network_rules(self):
|
|
"""Delete Dedicated public IP range with network rules on IP addresses
|
|
|
|
# Validate the following:
|
|
# 1. Create an account
|
|
# 2. Create a guest network in the account
|
|
# 3. Create a Public IP range
|
|
# 4 Dedicate the created IP range to user account
|
|
# 5. Acquire a public IP for the network
|
|
# 6. Verify that it is from the dedicated range
|
|
# 7. Create a LB rule for the public IP address
|
|
# 8. Try to delete the public IP range, the operation should fail
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
# Acquiring IP for source nat purpose
|
|
PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
LoadBalancerRule.create(
|
|
self.apiclient,
|
|
self.testdata["lbrule"],
|
|
ipaddressid=public_ip.ipaddress.id,
|
|
accountid=account.name,
|
|
networkid=isolated_network.id,
|
|
domainid=account.domainid)
|
|
|
|
with self.assertRaises(Exception):
|
|
public_ip_range.delete(self.apiclient)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_18_delete_network(self):
|
|
"""Delete network with public IP from dedicated range acquired in it
|
|
|
|
# Validate the following:
|
|
# 1. Create an account
|
|
# 2. Create a guest network in it
|
|
# 1. Create a Public IP range
|
|
# 3. Dedicate the created IP range to user account
|
|
# 5. Acquire a public IP in the network
|
|
# 6. Verify that the IP is from the dedicated range
|
|
# 7. Delete the network
|
|
# 8. Verify that the public IP range is still dedicated to the account
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
# Acuiring IP for source nat purpose
|
|
PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
isolated_network.delete(self.apiclient)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
public_ip_ranges[0].account,
|
|
account.name,
|
|
"Check account name is in listVlanIpRanges\
|
|
as the account public ip range is dedicated to")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_19_delete_account(self):
|
|
"""Create guest network in account with dedicated public ip range
|
|
|
|
# Validate the following:
|
|
# 1. Create an account
|
|
# 2. Create a Public IP range
|
|
# 3. Dedicate the created IP range to user account
|
|
# 4. Delete the account
|
|
# 5. Verify that the public IP range is released back to the system
|
|
"""
|
|
# Create Account
|
|
account = Account.create(
|
|
self.apiclient,
|
|
self.testdata["account"],
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup.append(account)
|
|
|
|
isolated_network = Network.create(
|
|
self.apiclient,
|
|
self.testdata["isolated_network"],
|
|
account.name,
|
|
account.domainid,
|
|
networkofferingid=self.isolated_network_offering.id)
|
|
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
PublicIpRange.dedicate(
|
|
self.apiclient,
|
|
public_ip_range.vlan.id,
|
|
account=account.name,
|
|
domainid=account.domainid
|
|
)
|
|
|
|
formatted_startip = IPAddress(
|
|
self.testdata["publiciprange"]["startip"])
|
|
formatted_endip = IPAddress(self.testdata["publiciprange"]["endip"])
|
|
public_ip1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
accountid=account.name,
|
|
zoneid=self.zone.id,
|
|
domainid=account.domainid,
|
|
networkid=isolated_network.id)
|
|
|
|
formatted_publicip = IPAddress(public_ip1.ipaddress.ipaddress)
|
|
|
|
self.assertTrue(int(formatted_startip) <=
|
|
int(formatted_publicip) <= int(formatted_endip),
|
|
"publicip should be from the dedicated range")
|
|
|
|
account.delete(self.apiclient)
|
|
self.cleanup.remove(account)
|
|
|
|
public_ip_ranges = PublicIpRange.list(
|
|
self.apiclient,
|
|
id=public_ip_range.vlan.id
|
|
)
|
|
self.assertEqual(validateList(public_ip_ranges)[0], PASS,
|
|
"public ip ranges list validation failed")
|
|
self.assertEqual(
|
|
str(public_ip_ranges[0].account).lower(),
|
|
"system",
|
|
"Account name should be system")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_20_release_range_not_dedicated(self):
|
|
"""Create guest network in account with dedicated public ip range
|
|
|
|
# Validate the following:
|
|
# 1. Create a Public IP range
|
|
# 2. Do not dedicate it to any account, try to release it
|
|
# 3. Operation should fail as the range is not dedicated
|
|
"""
|
|
public_ip_range = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.testdata["publiciprange"]
|
|
)
|
|
self.cleanup.append(public_ip_range)
|
|
|
|
with self.assertRaises(Exception):
|
|
public_ip_range.release(self.apiclient)
|
|
return
|