def test_disconnect_no__write_permission(self):
        mock = self.mock_for_disconnect()
        self.alter(self.ID_FOR_CONNECTION, {self.XML_KEY: mock})

        response = self.client_no_write_permission().delete(
            self.URL_REMOVE_CONNECTION % (self.ID_DISCONNECT_VALID, "0"))
        valid_response(response, httplib.PAYMENT_REQUIRED)

 def test_save_ipv6_valid(self):
     mock = self.mock_network_hosts_ip_valid()
     mock['id_vlan'] = 17
     response = self.client_autenticado().putXML(
         self.URL_SAVE_NETWORK_IPV6, {self.XML_KEY_NETWORK_IP: mock})
     valid_response(response)
     valid_content(response, self.XML_KEY_NETWORK_IP)

 def test_get_by_equip_old_valid(self):
     response = self.client_autenticado().get(
         self.URL_GET_BY_EQUIP_OLD % self.EQUIP_VALID)
     valid_response(response)
     content = valid_content(response, self.XML_KEY)
     from_db = Interface.objects.filter(equipamento=self.EQUIP_VALID)
     assert len(content) == len(from_db)

 def test_alter_valid(self):
     mock = self.mock_network_alter_valid()
     response = self.client_autenticado().postXML(
         self.URL_ALTER, {self.XML_KEY_ALTER: mock})
     valid_response(response)
     net = NetworkIPv4.get_by_pk(self.ID_NETWORK_IPV4_ALTER_VALID)
     self.valid_network_attr(mock, model_to_dict(net))

 def test_alter_valid(self):
     mock = self.mock_valid_alter()
     response = self.client_autenticado().postXML(
         self.URL_ALTER, {self.XML_KEY: mock})
     valid_response(response)
     tpa = EquipamentoAcesso.get_by_pk(self.ID_ALTER_VALID)
     self.valid_attr(mock, model_to_dict(tpa))

 def test_save_ipv4_valid(self):
     mock = self.mock_network_ip_valid()
     mock[self.KEY_ATTR] = 26
     response = self.client_autenticado().postXML(
         self.URL_SAVE_NETWORK_IPV4, {self.XML_KEY_NETWORK_IP: mock})
     valid_response(response)
     valid_content(response, self.XML_KEY_NETWORK_IP)

 def test_save_none(self):
     mock = self.mock_valid()
     mock["nome"] = "InterfaceNone"
     mock[self.KEY_ATTR] = self.NONE_ATTR
     response = self.save({self.XML_KEY: mock})
     valid_response(response)
     valid_content(response, self.XML_KEY)

    def test_alter_valid(self):
        mock = self.mock_valid_alter()
        response = self.alter(self.ID_ALTER_VALID, {self.XML_KEY: mock})
        valid_response(response)

        nt = TipoRede.get_by_pk(self.ID_ALTER_VALID)
        self.valid_attr(mock, model_to_dict(nt))

 def test_authenticate_wrong_password(self):
     mock = self.user_login_valid()
     mock['password'] = string_generator(10)
     response = self.client_autenticado().postXML(
         self.URL_AUTHENTICATE, {self.XML_KEY: mock})
     valid_response(response)
     assert xml2dict(response.content) == None

    def test_get_by_equipment_no_read_permission(self):
        equip_access_map = dict()
        equip_access_map['name'] = self.EQUIPMENT_NAME_VALID

        response = self.client_no_read_permission().postXML(
            self.URL_GET_BY_EQUIP_NAME, {self.XML_KEY: equip_access_map})
        valid_response(response, httplib.PAYMENT_REQUIRED)

 def test_get_by_equipment(self):
     response = self.client_autenticado().get(
         self.URL_GET_BY_EQUIP % self.ID_EQUIPMENT_VALID)
     valid_response(response)
     content = valid_content(response, self.XML_KEY, True)
     query = Q(equipamentoambiente__equipamento=self.ID_EQUIPMENT_VALID)
     valid_get_filtered(content, Ambiente, query)

 def test_get_by_env_vip_valid(self):
     response = self.get_by_env_vip(self.ID_ENV_VIP_VALID)
     valid_response(response)
     content = valid_content(response, self.XML_KEY)
     assert len(content) == len(
         self.OBJ.objects.select_related().filter(optionvipenvironmentvip__environment=self.ID_ENV_VIP_VALID)
     )

 def test_change_pass_maxsize(self):
     data = self.user_change_pass_valid()
     data['password'] = string_generator(46)
     response = self.client_autenticado().postXML(
         self.URL_CHANGE_PASS, {self.XML_KEY: data})
     valid_response(response, status_code=httplib.INTERNAL_SERVER_ERROR)
     self._attr_invalid(response)

 def test_authenticate_none_password(self):
     mock = self.user_login_valid()
     mock['password'] = None
     response = self.client_autenticado().postXML(
         self.URL_AUTHENTICATE, {self.XML_KEY: mock})
     valid_response(response, status_code=httplib.INTERNAL_SERVER_ERROR)
     self._attr_invalid(response)

 def test_authenticate_empty_username(self):
     mock = self.user_login_valid()
     mock['username'] = ''
     response = self.client_autenticado().postXML(
         self.URL_AUTHENTICATE, {self.XML_KEY: mock})
     valid_response(response, status_code=httplib.INTERNAL_SERVER_ERROR)
     self._attr_invalid(response)

 def test_alter_valid(self):
     mock = self.mock_valid_alter()
     response = self.alter(self.ID_ALTER_VALID, {self.XML_KEY: mock})
     valid_response(response)
     equip_group_right = DireitosGrupoEquipamento.get_by_pk(
         self.ID_ALTER_VALID)
     self.valid_attr(mock, model_to_dict(equip_group_right))

 def test_save_valid(self):
     mock = self.mock_valid()
     response = self.save({self.XML_KEY: mock})
     valid_response(response)
     equipment_type = valid_content(response, self.XML_KEY)
     from_db = EquipamentoAmbiente.objects.get(
         equipamento=self.ID_EQUIPMENT_VALID, ambiente=self.ID_ENVIRONMENT_VALID)
     assert str(from_db.id) == str(equipment_type['id'])

 def test_get_vips_by_env_id_valid(self):
     response = self.client_autenticado().get(self.URL_GET_VIPS_FROM_ENV_VIP % self.ID_VALID_VIPS_ASSOCIATION)
     valid_response(response)
     content = valid_content(response)
     query = Q(ip__networkipv4__ambient_vip__id=self.ID_VALID_VIPS_ASSOCIATION) | Q(
         ipv6__networkipv6__ambient_vip__id=self.ID_VALID_VIPS_ASSOCIATION
     )
     valid_get_filtered(content, RequisicaoVips, query)

    def test_get_by_equipment(self):
        response = self.client_autenticado().get(
            self.URL_GET_EQUIPMENT % self.ID_VALID)
        valid_response(response)
        content = valid_content(response, "script", True)

        query = Q(equipamento__id=self.ID_VALID)
        valid_get_filtered(content, EquipamentoRoteiro, query)

    def test_get_by_script_type(self):
        response = self.client_autenticado().get(
            self.URL_GET_SCRIPT_TYPE % self.ID_VALID)
        valid_response(response)
        content = valid_content(response, "script", True)

        query = Q(tipo_roteiro__id=self.ID_VALID)
        valid_get_filtered(content, self.OBJ, query)