def test_modify_nas_server(self):
server = UnityNasServer(_id='nas_1', cli=t_rest())
new_sp = UnityStorageProcessor(_id='spa', cli=t_rest())
resp = server.modify(name='esa_nasserver', sp=new_sp)
assert_that(resp.is_ok(), equal_to(True))
server.update()
assert_that(server.name, equal_to('esa_nasserver'))
assert_that(server.home_sp.id, equal_to('spa'))
def test_create_file_interface_ipv6_success(self):
server = UnityNasServer(_id='nas_2', cli=t_rest())
file_interface_ipv6 = server.create_file_interface(
ip_port='spa_eth2',
ip='2001:db8:0:1:f816:3eff:fe76:35c4',
v6_prefix_length='64',
gateway='2001:db8:0:1::1',
role=FileInterfaceRoleEnum.PRODUCTION)
assert_that(file_interface_ipv6.ip_address,
equal_to('2001:db8:0:1:f816:3eff:fe76:35c4'))
assert_that(file_interface_ipv6.v6_prefix_length, equal_to(64))
assert_that(file_interface_ipv6.netmask, equal_to(None))
def test_properties(self):
server = UnityNasServer(_id='nas_1', cli=t_rest())
assert_that(server.existed, equal_to(True))
assert_that(server.id, equal_to('nas_1'))
assert_that(server.name, equal_to('esa_nasserver'))
assert_that(server.health, instance_of(UnityHealth))
assert_that(server.home_sp, instance_of(UnityStorageProcessor))
assert_that(server.current_sp, instance_of(UnityStorageProcessor))
assert_that(server.pool, instance_of(UnityPool))
assert_that(server.size_allocated, equal_to(2952790016))
assert_that(server.is_replication_enabled, equal_to(False))
assert_that(server.is_replication_destination, equal_to(False))
assert_that(server.replication_type,
equal_to(ReplicationTypeEnum.NONE))
assert_that(server.default_unix_user, none())
assert_that(server.default_windows_user, none())
assert_that(server.current_unix_directory_service,
equal_to(NasServerUnixDirectoryServiceEnum.NONE))
assert_that(server.is_multi_protocol_enabled, equal_to(False))
assert_that(server.is_windows_to_unix_username_mapping_enabled, none())
assert_that(server.allow_unmapped_user, none())
assert_that(server.cifs_server, instance_of(UnityCifsServerList))
assert_that(server.preferred_interface_settings,
instance_of(UnityPreferredInterfaceSettings))
assert_that(server.file_dns_server, instance_of(UnityFileDnsServer))
assert_that(server.file_interface, instance_of(UnityFileInterfaceList))
assert_that(server.virus_checker, instance_of(UnityVirusChecker))
def f():
pool = UnityPool(_id='pool_1', cli=t_rest())
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_1')
pool.create_nfs_share(
nas_server,
name='job_share_failed',
size=1)
def test_create_nfs_share_success(self):
pool = UnityPool(_id='pool_5', cli=t_rest())
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_6')
job = pool.create_nfs_share(
nas_server,
name='513dd8b0-2c22-4da0-888e-494d320303b6',
size=4294967296)
assert_that(JobStateEnum.COMPLETED, equal_to(job.state))
def test_replicate(self, dst_nas, replication_name, remote_system,
expected_rep_name):
if remote_system:
remote_system = UnityRemoteSystem(_id=remote_system, cli=t_rest())
nas = UnityNasServer.get(cli=t_rest(), _id='nas_6')
rep_session = nas.replicate(dst_nas,
60,
replication_name=replication_name,
remote_system=remote_system)
assert_that(rep_session.name, equal_to(expected_rep_name))
def test_create_nfs_share_failed(self):
pool = UnityPool.get(cli=t_rest(), _id='pool_5')
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_6')
self.assertRaisesRegexp(
ex.JobStateError,
'Job State: FAILED. Error Detail: ',
UnityJob.create_nfs_share,
cli=t_rest(), pool=pool, nas_server=nas_server,
name='613dd8b0-2c22-4da0-888e-494d320303b7',
size=4294967296,
async=False)
def f():
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_6')
remote_system = UnityRemoteSystem(_id='RS_6', cli=t_rest())
nas_server.replicate_with_dst_resource_provisioning(
60,
'pool_1',
dst_nas_server_name='nas-liangr',
remote_system=remote_system,
replication_name='nas-server-rep',
dst_sp=None,
is_backup_only=False)
def test_replicate_with_dst_resource_provisioning(self,
dst_nas_server_name,
remote_system, rep_name,
dst_sp, is_backup_only,
expected_rep_session_id):
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_6')
if remote_system:
remote_system = UnityRemoteSystem(_id=remote_system, cli=t_rest())
rep_session = nas_server.replicate_with_dst_resource_provisioning(
60,
'pool_1',
dst_nas_server_name=dst_nas_server_name,
remote_system=remote_system,
replication_name=rep_name,
dst_sp=dst_sp,
is_backup_only=is_backup_only)
assert_that(rep_session.id, equal_to(expected_rep_session_id))
def test_create_nfs_share_success_all_params(self):
pool = UnityPool(_id='pool_5', cli=t_rest())
nas_server = UnityNasServer.get(cli=t_rest(), _id='nas_6')
size = 3 * 1024 ** 3
job = pool.create_nfs_share(
nas_server,
name='513dd8b0-2c22-4da0-888e-494d320303b7',
size=size, is_thin=True,
tiering_policy=TieringPolicyEnum.AUTOTIER_HIGH,
default_access=NFSShareDefaultAccessEnum.READ_WRITE,
min_security=NFSShareSecurityEnum.KERBEROS,
no_access_hosts_string='Host_1',
read_only_hosts_string='Host_2',
read_write_hosts_string='Host_3',
read_only_root_hosts_string='Host_5,Host_4',
root_access_hosts_string='Host_6',
anonymous_uid=10001,
anonymous_gid=10002,
export_option=20001)
assert_that(JobStateEnum.COMPLETED, equal_to(job.state))
def test_enable_cifs_service_default_domain_name(self):
server = UnityNasServer(_id='nas_2', cli=t_rest())
server.enable_cifs_service(name='c_server2',
domain_username='******',
domain_password='******')
def test_create_dns_single_address(self):
server = UnityNasServer.get(t_rest(), 'nas_6')
dns = server.create_dns_server('emc.dev', '4.4.4.4')
assert_that(dns.existed, equal_to(True))
assert_that(dns.addresses, only_contains('4.4.4.4'))
def test_create_dns_server_success(self):
server = UnityNasServer.get(t_rest(), 'nas_4')
dns = server.create_dns_server('emc.dev', '2.2.2.2', '3.3.3.3')
assert_that(dns.addresses, only_contains('2.2.2.2', '3.3.3.3'))
def test_enable_nfs_service_success(self):
server = UnityNasServer(_id='nas_5', cli=t_rest())
server.create_nfs_server(nfs_v4_enabled=True)
def test_create_nfs_server_success(self):
server = UnityNasServer(_id='nas_5', cli=t_rest())
nfs_server = server.create_nfs_server(nfs_v4_enabled=True)
assert_that(nfs_server.id, equal_to('nfs_3'))
assert_that(nfs_server.nfs_v4_enabled, equal_to(True))
assert_that(nfs_server.host_name, none())
def test_enable_cifs_service_success(self):
server = UnityNasServer(_id='nas_5', cli=t_rest())
server.create_cifs_server(name='c_server1',
workgroup='CEDRIC',
local_password='******')
def test_get_cifs_server_from_nas_server(self):
server = UnityNasServer(_id='nas_2', cli=t_rest())
server = UnityCifsServer.get(t_rest(), server)
assert_that(server, instance_of(UnityCifsServer))
assert_that(server.domain, equal_to('win2012.dev'))
def test_create_file_interface_success(self):
server = UnityNasServer(_id='nas_2', cli=t_rest())
fi = server.create_file_interface(
'spa_eth2', '1.1.1.1', role=FileInterfaceRoleEnum.PRODUCTION)
assert_that(fi.ip_address, equal_to('1.1.1.1'))
def test_create_nas3_success(self):
ret = UnityNasServer.create(t_rest(), 'nas3', 'spa', 'pool_1')
assert_that(ret.name, equal_to('nas3'))
assert_that(ret.existed, equal_to(True))
def test_get_cifs_server_available(self):
server = UnityNasServer(_id='nas_2', cli=t_rest())
cifs_server = server.get_cifs_server()
assert_that(cifs_server.domain, equal_to('win2012.dev'))
def test_create_nas_server_in_tenant(self):
UnityNasServer.create(t_rest('4.1.0'), 'nas5', 'spa',
'pool_1', tenant='tenant_1')
def test_create_success(self):
server = UnityNasServer.get(t_rest(), 'nas_4')
dns = UnityFileDnsServer.create(t_rest(), server, 'emc.dev',
['2.2.2.2', '3.3.3.3'])
assert_that(dns.addresses, only_contains('2.2.2.2', '3.3.3.3'))
def f():
server = UnityNasServer(_id='nas_5', cli=t_rest())
server.enable_cifs_service(name='c_server2',
workgroup='CEDRIC',
local_password='******')
def test_create_cifs_server_success(self):
server = UnityNasServer(_id='nas_5', cli=t_rest())
cifs_server = server.create_cifs_server(name='c_server1',
workgroup='CEDRIC',
local_password='******')
assert_that(cifs_server.workgroup, equal_to('CEDRIC'))
def test_create_success(self):
server = UnityNasServer.get(t_rest(), 'nas_4')
dns = UnityFileDnsServer.create(t_rest(), server, 'emc.dev',
['2.2.2.2', '3.3.3.3'])
assert_that(dns.addresses, only_contains('2.2.2.2', '3.3.3.3'))
def f():
server = UnityNasServer(_id='nas_3', cli=t_rest())
server.get_cifs_server()
def f():
server = UnityNasServer(_id='not_found', cli=t_rest())
server.delete()
def f():
UnityNasServer.create(t_rest(), 'nas4', 'spa', 'pool_1')
def test_delete_success(self):
server = UnityNasServer(_id='nas_3', cli=t_rest())
resp = server.delete()
assert_that(resp.body, equal_to({}))
