def create_volume_with_cds_size(self):

      client_token = generate_client_token()

      #设置CDS磁盘容量(GB)必须为大于0的整数，范围0~5120GB
      cds_size_in_gb = 5

      #设置付费方式
      billing = pre_paid_billing

      #批量创建的CDS磁盘的个数，必须为大于0的整数，单次创建不能超过5个。可选参数，缺省为1
      purchase_cpunt = 1

      #设置cds磁盘存储类别
      #std1：普通型
      #hp1：高性能型
      #cloud_hp1：SSD型
      #local：本地盘
      #sata：sata磁盘，创建DCC字实例专用
      #ssd：ssd磁盘，创建DCC子实例专用

      storage_type = 'hp1'

      #指定区域信息，默认为空由系统自动选择
      zone_name = 'cn-bj-a'

      self.assertEqual(

            type(self.client.create_volume_with_cds_size(cds_size_in_gb,
                                                                 billing=billing,
                                                                 purchase_count=purchase_count,
                                                                 storage_type=storage_type,
                                                                 zone_name=zone_name,
                                                                 client_token=client_token),
            baidubce.bce_response.BceResponse)

def create_volume_with_snapshot_id(self):

      client_token = generate_client_token()

      #设置CDS磁盘容量(GB)必须为大于0的整数，范围0~5120GB
      snapshot_id = 'your-choose-snap-shot-id'

      #设置付费方式
      billing = pre_paid_billing

      #批量创建的CDS磁盘的个数，必须为大于0的整数，单次创建不能超过5个。可选参数，缺省为1
      purchase_cpunt = 1

      #设置cds磁盘存储类别
      #std1：普通型
      #hp1：高性能型
      #cloud_hp1：SSD型
      #local：本地盘
      #sata：sata磁盘，创建DCC字实例专用
      #ssd：ssd磁盘，创建DCC子实例专用
      storage_type = 'hp1'

      #指定区域信息，默认为空由系统自动选择
      zone_name = 'cn-bj-a'

      self.assertEqual(

            type(self.client.create_volume_with_snapshot_id(snapshot_id,
                                                            billing=billing,
                                                            purchase_count=purchase_count,
                                                            storage_type=storage_type,
                                                            zone_name=zone_name,
                                                            client_token=client_token),
            baidubce.bce_response.BceResponse)

def list_volumes(self):

      #查询某一实例挂载的磁盘列表
      self.client.list_volumes(instance_id = 'your-choose-instance-id')

      #查询某一区域下的磁盘列表
      self.client.list_volumes(zone_name = 'your-choose-zone-name')

      #批量获取列表的查询起始位置，是一个由系统产生的字符串
      self.client.list_volumes(marker = 'your-marker')

      #设置每页包含的最大数量，默认为1000
      self.client.list_volumes(max_keys = 100)

      print self.client.list_instances()

def get_volume(self):
      volume_id = 'your-choose-volume-id'

      self.assertEqual(

            type(self.client.get_volume(volume_id)), 

            baidubce.bce_response.BceResponse)

def attach_volume(self):

      #设置要挂载的磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置要挂载的实例ID
      instance_id = 'your-choose-instance-id'  

      self.assertEqual(

            type(self.client.attach_volume(volume_id,instance_id)), 

            baidubce.bce_response.BceResponse)

def detach_volume(self):

      #设置要卸载的磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置所挂载的实例ID
      instance_id = 'your-choose-instance-id'  

      self.assertEqual(

            type(self.client.detach_volume(volume_id,instance_id)), 

            baidubce.bce_response.BceResponse)

def release_volume(self):

      #设置要释放的磁盘ID
      volume_id = 'your-choose-volume-id'

      self.assertEqual(

            type(self.client.release_volume(volume_id)), 

            baidubce.bce_response.BceResponse)

def resize_volume(self):

      #设置被扩容磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置新的CDS磁盘容量，必须为大于0的整数，单位为GB，范围0~5120GB
      resize_cds_size_in_gb = 10

      client_token = generate_client_token()   

      self.assertEqual(

            type(self.client.resize_volume(volume_id,resize_cds_size_in_gb,client_token)), 

            baidubce.bce_response.BceResponse)

def rollback_volume(self): 

      #待回滚的磁盘ID
      #待系统盘则为实例ID
      volume_id = 'your-choose-volume-id'

      #用于回滚指定磁盘的快照ID，必须为 volumeId 所创建的快照
      snapshot_id = 'your-choose-snapshot-id'

      self.assertEqual(

            type(self.client.rollback_volume(volume_id,snapshot_id)), 

            baidubce.bce_response.BceResponse)

def purchase_reserved_volume(self):

      #待续费磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置付费方式
      billing = pre_paid_billing

      client_token = generate_client_token()   

      self.assertEqual(

            type(self.client.purchase_reserved_volume(volume_id,billing,client_token)), 

            baidubce.bce_response.BceResponse)

def modify_volume_attribute(self):

      #待修改磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置磁盘新名称
      cdsName = 'your-new-cds-name'

      self.assertEqual(

            type(self.client.modify_volume_Attribute(volume_id=volume_id,cdsName=cdsName)), 

            baidubce.bce_response.BceResponse)

def modify_volume_charge_type(self):

      #待修改磁盘ID
      volume_id = 'your-choose-volume-id'

      #设置磁盘新付费方式，变更为预付费需指定付费时长
      pre_paid_billing = bcc_model.Billing('Prepaid', 2)
      billing = pre_paid_billing

      self.assertEqual(

            type(self.client.modify_volume_charge_type(volume_id=volume_id,billing=billing)), 

            baidubce.bce_response.BceResponse)

def test_release_volume_new(self):
        """
        test case for release_volume_new
        """
        resp = self.client.release_volume_new("v-0RMyIJRq", manual_snapshot='on')
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)

 def test_auto_renew_cds_volume(self):
        """
        test case for auto_renew_cds_volume
        """
        resp = self.client.auto_renew_cds_volume("v-0RMyIJRq", renew_time=1, renew_time_unit='month')
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)

def test_cancel_auto_renew_cds_volume(self):
        """
        test case for cancel_auto_renew_cds_volume
        """
        resp = self.client.cancel_auto_renew_cds_volume("v-0RMyIJRq")
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)

def test_get_available_disk_info(self):
        """
        test case for get_available_disk_info
        """
        resp = self.client.get_available_disk_info("cn-bj-a")
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)

def test_tag_volume(self):
        """
        test case for get_available_disk_info
        """
        tag1 = bcc_model.TagModel(tagKey='TestKey02',
                                  tagValue='TestValue02')
        tag2 = bcc_model.TagModel(tagKey='TestKey03',
                                  tagValue='TestValue03')
        tags = []
        tags.append(tag1)
        tags.append(tag2)
        resp = self.client.tag_volume("v-0RMyIJRq", relation_tag=True, tags=tags)
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)

def test_untag_volume(self):
        """
        test case for get_available_disk_info
        """
        tag1 = bcc_model.TagModel(tagKey='TestKey02',
                                  tagValue='TestValue02')
        tag2 = bcc_model.TagModel(tagKey='TestKey03',
                                  tagValue='TestValue03')
        tags = []
        tags.append(tag1)
        tags.append(tag2)
        resp = self.client.untag_volume("v-0RMyIJRq", relation_tag=True, tags=tags)
        self.assertEqual(
            type(resp),
            baidubce.bce_response.BceResponse)
        if resp is not None and resp.content is not None:
            print(json.loads(resp.content.decode('utf-8')))
        else:
            print(resp)