Eu apenas imagino ser capaz de gravar scripts que interagirem automaticamente com seu aplicativo iOS e ser capazes de verificar os resultados. Com automação de interface do usuário você pode. A UI Automation é uma ferramenta fornecida pela Apple para executar um nível mais alto de teste em seu aplicativo iOS além do que pode ser alcançado com xctest.
1. caixa branca versus teste de caixa preta
Você pode ter ouvido a comparação de testes de caixa branca contra testes de caixa negra em relação a como um software poderia ser testado. Se você não estiver familiarizado com esses conceitos, deixe-me explicar como eles funcionam.
teste na caixa branca
Imagine que há um pedaço de software em execução dentro de uma caixa. Com testes de caixa branca, você pode ver dentro da caixa e ver todas as peças de como o software funciona e, em seguida, tomar decisões informadas sobre como testar o software. Você também pode ter ganchos de nível mais profundos no software de teste que você escreve.
O teste da unidade é um teste de caixa branca. Ao escrever testes de unidade, o testador tem acesso detalhado ao código em teste. O verificador pode realmente escrever testes que aproveitam o software em teste no método ou unidade.
No desenvolvimento do software iOS, usamos o quadro XCtest para executar este tipo de teste. Dê uma olhada em outro tutorial que escrevi sobre como começar com xctest.
Teste de caixa preto
em testes de caixa preta, a caixa é opaca. O testador não pode ver dentro da caixa. O testador não pode acessar e não sabe sobre a implementação do código base para escrever testes. Em vez disso, o testador é forçado a usar o aplicativo como um usuário final interagiria com o aplicativo e esperando por sua resposta, verificando os resultados.
Existem pelo menos duas maneiras de executar esse tipo de teste.
- um testador que executa repetidamente e manual uma série de etapas predefinidas e verifica visualmente os resultados.
- use ferramentas especializadas para testar o aplicativo com a API que se comportam de forma semelhante a Um ser humano interage.
no desenvolvimento de aplicativos iOS, a Apple fornece uma ferramenta chamada automação da UI para executar testes na caixa preta.
2. Qual é a interface do usuário Automação?
UI Automation é uma ferramenta que a Apple fornece e mantém o nível mais alto automatizado de aplicativos iOS. Os testes são escritos em javascript, aderindo a uma API definida pela Apple.
Os testes de redação podem ser simplificados ao confiar em etiquetas de acessibilidade para elementos de interface do usuário em seu aplicativo. Não se preocupe, se você não tiver estes definidos, existem alternativas disponíveis.
A API da UI Automação não tem o formato típico baseado em XUnit para escrever testes. Uma diferença com os testes unitários é que o testador deve registrar manualmente sucesso e falhas. Os testes de automação da UI são executados a partir do instrumento de automação dentro da ferramenta Instruments que acompanha as ferramentas do desenvolvedor da Apple. Os testes podem ser executados no simulador do iOS ou em um dispositivo físico.
3. Escreva testes de automação da interface do usuário
Etapa 1: Abra o projeto de exemplo
Atualizei o projeto de exemplo usado no tutorial anterior em testes iOS com alguns elementos adicionais da interface do usuário que fornecem alguns ganchos úteis para adicionar testes de automação da UI. Baixe o projeto do Github. Abra o projeto e execute o aplicativo para garantir que tudo esteja funcionando como esperado. Você deve ver uma interface de usuário semelhante à mostrada abaixo.
antes de escrever qualquer Teste, sinta-se à vontade para tentar o aplicativo de amostra para se familiarizar com sua funcionalidade. Como usuário, você pode inserir texto no campo de texto e pressione o botão para ver uma etiqueta na tela que mostra a cadeia invertida inserida.
Etapa 2: criar uma automação Ui
Agora que você está familiarizado com o aplicativo de amostra, é hora de adicionar um teste de automação da UI. A automação da UI é uma ferramenta que pode ser encontrada em instrumentos. Para executar o aplicativo de amostra de instrumento, selecione Produto > Perfil no menu Xcode. Selecione Automação na lista de ferramentas.
A janela principal do instrumento será aberta com um único instrumento pronto para ser executado, o Instrumento de automação (o instrumento de automação executa casos de teste de automação da UI). Você também verá uma área na metade inferior da janela que se parece com um editor de texto. Este é o editor de scripts. É aqui que você escreverá seus testes de automação da UI. Para este primeiro teste, siga as instruções abaixo, adicionando cada linha ao script no editor de script.
Iniciar armazenando uma referência ao campo de texto em uma variável.
var inputField = target.frontMostApp().mainWindow().textFields();
Defina o valor do campo de texto.
Verifique se o valor foi definido corretamente e, se Foi, passe o teste. Falha no teste se não era assim.
if (inputField.value() != "hi") UIALogger.logFail("The Input Field was NOT able to be set with the string!");else UIALogger.logPass("The Input Field was able to be set with the string!");
Enquanto este teste é bastante trivial, ele tem valor. Acabamos de escrever um teste que prova a presença de um campo de texto quando o aplicativo é lançado e teste se uma cadeia aleatória puder ser estabelecida como o valor do campo de texto. Se você não acredita em mim, exclua o campo de texto Storyboard e execute o teste. Você verá que falha.
Este teste demonstra três importantes sistemas de escrita de testes de automação da interface do usuário. Primeiro, mostra como acessar um elemento de interface de usuário simples, o campo de texto. Especificamente, acessamos um dicionário de todos os campos de texto na visão base da aplicação através de target.frontMostApp().mainWindow().textFields() e, em seguida, procuramos o campo de texto que nos interessa ao procurar a chave que tem a chave que Input Field. Essa chave é na verdade o rótulo de acessibilidade do campo de texto. Nesse caso, ele é definido no script gráfico. Também podemos definir o rótulo de acessibilidade no código usando a propriedade em NSObject.
Acesso ao diretor da janela do aplicativo, a aplicação mais frontal e o objetivo são comuns ao trabalhar com a automação da interface do usuário. Eu mostrarei como fazer isso mais fácil e menos detalhado mais tarde neste tutorial.
segundo, isso mostra que você pode interagir com os elementos da interface do usuário na tela. Nesse caso, estabelecemos o valor do campo de texto, imitando o usuário que interage com o aplicativo ao inserir texto no campo de texto.
e terceiro, o exemplo também mostra uma técnica para verificar o que acontece em a aplicação. Se o valor for estabelecido com sucesso, o teste passa. Se o valor não estiver definido, o teste falhará.
Etapa 3: Salvar testes
Enquanto escrevendo testes no editor de script é conveniente, ele rapidamente se torna pesado e difícil de manter. Se você deixar instrumentos, qualquer alteração não salva é descartada. Precisamos manter os testes que escrevemos. Basta copiar e colar seu teste em um novo documento no seu editor de texto favorito e salve-o. Você pode encontrar os testes criados neste tutorial no projeto de exemplo em Jumblify / Jumblifyss / AutomationTes.js.
Para executar o teste, selecione a guia Médio no painel direito, ao lado do editor de scripts, e selecione Adicionar > Importar.
Você será solicitado a selecionar o script para importar. Navegue até o script salvo e imprime-o. Você ainda pode alterar o script no editor de scripts. Qualquer alteração será salva automaticamente no arquivo externo que você criou.
Passo 4: Tocar um botão
Nós atualizamos nosso teste para testar a interação com o botão. Nosso teste já adiciona texto ao campo de texto, portanto, precisamos apenas adicionar código para tocar no botão. Considere primeiro como encontrar o botão na exibição para que você possa tocar. Há pelo menos três maneiras de conseguir isso e cada abordagem tem sua compensação.
foco 1
Nós podemos programar programando uma coordenada (x, y) na tela . Fazemos isso com a seguinte linha de código:
target.tap({x: 8.00, y: 50.00});
Claro, não tenho ideia se essas são as coordenadas do botão no botão tela e não vou me preocupar com isso, porque essa abordagem não é a ferramenta certa para este trabalho. Eu só mencho isso para que você saiba que existe. Use o método Tap In target to tocar em um botão é propenso a erros, porque esse botão nem sempre é encontrado nessa coordenada específica. / P>
foco 2
Também é possível encontrar o botão pesquisando na matriz de botão na janela principal, de maneira semelhante a como acessarmos o campo de texto no primeiro teste.Em vez de acessar o botão usando diretamente uma chave, podemos recuperar uma matriz de botão na janela principal e codificar um índice matric para obter uma referência ao botão.
target.frontMostApp().mainWindow().buttons().tap();
Esta abordagem é um pouco melhor. Não estamos codificando uma coordenada, mas estamos codificando um índice matricial para encontrar o botão. Se adicionarmos outro botão na página, você pode acidentalmente quebrar este teste.
foco 3
Isso leva-me à terceira maneira de encontrar o botão na página, Usando tags de acessibilidade Usando um rótulo de acessibilidade, podemos acessar diretamente o botão, eu simplesmente gostava de encontrar um objeto em um dicionário com uma chave.
target.frontMostApp().mainWindow().buttons().tap();
No entanto, no entanto, Se você adicionar a linha anterior ao script e executá-lo, receberá um erro.
É por isso que não definimos o rótulo de acessibilidade para o botão. Para fazer isso, vá para Xcode e abra o storyboard do projeto. Procure o botão na exibição e abra o inspetor de identidade à direita (visualizar > Utilitários Inspetor de identidade). Certifique-se de que a acessibilidade esteja ativada e configure o rótulo para o botão do botão jumblify.
para executar O teste novamente, você deve executar o aplicativo de Xcode selecionando o produto > Executar e, em seguida, descrever o aplicativo novamente selecionando o produto > Perfil. Isso executa os testes e cada teste deve acontecer agora.
Etapa 5: Verifique a cadeia confusa (corrente desleixada)
Como mencionei anteriormente, nosso aplicativo leva uma string como entrada e, quando O usuário toca no botão, ele mostra a string invertida. Precisamos adicionar mais um teste para verificar se a cadeia de entrada foi invertida corretamente. Para verificar se o UILabel está cheio com a corrente correta, precisamos descobrir como referir-se a UILabel e verifique a corrente mostrando. Este é um problema comum ao escrever testes de automação, isto é, descobrir como se referir a um elemento no aplicativo para fazer uma afirmação sobre isso.
Há um método em quase todos os objetos na API Automação da interface do usuário, logElementTree. Este método registra os elementos aninhados de um determinado elemento. Isso é muito útil para entender a hierarquia de elementos no aplicativo e ajudar a determinar como orientar um elemento específico.
Vamos ver como isso funciona gravando a árvore de elementos da janela principal. Dê uma olhada na próxima linha de código.
target.frontMostApp().mainWindow().logElementTree();
Adicione esta linha ao script de teste resulta no seguinte resultado:
Como você pode ver, há um sub-elemento UIAStaticText do UIAWindow e você também pode ver que você tem um nome de ih, Qual é também a string invertida que precisamos verificar. Ahora, para completar nuestra prueba, solo necesitamos agregar código para acceder a este elemento y verificar que esté presente.
¿Por qué solo necesitamos verificar si el elemento UIAStaticText está presente? Como o nome do elemento é a cadeia invertida da cadeia de entrada, verificando sua presença confirma que a sequência foi investida corretamente. Se o elemento não existir quando a referência for feita pelo nome, a seqüência invertida, significa que a string não foi invertida corretamente.
var stringResult = target.frontMostApp().mainWindow().staticTexts();if (! stringResult.isValid()) UIALogger.logFail("The output text was NOT set with the correctly reversed string!");else UIALogger.logPass("The output text was set with the correctly reversed string!");
4. raspando o Superfície
Existem muitas outras maneiras pelas quais um usuário final pode interagir com um dispositivo iOS enquanto estiver usando seu aplicativo. Isso significa que existem muitas outras maneiras de usar a interface do usuário da UI para simular essas interações. Em vez de tentar capturar uma lista completa dessas interações, irei para a documentação de referência de automação da UI.
Para cada tipo de objeto com o qual você pode interagir, você pode ver a lista de métodos disponíveis em que objeto. Alguns métodos são para recuperar atributos sobre o objeto, enquanto outros são para simular interação tátil, como flickInsideWithOptions em UIAWindow.
Gravando uma sessão
Como você tenta experimentar aplicativos mais e mais complicados com automação da interface do usuário, você verá que às vezes é bastante tedioso usar repetidamente Para encontrar o elemento que você está procurando.Isso também se torna tedioso e complexo para aplicações com uma hierarquia de visão complexa ou navegação. Nesses casos, você pode usar outra função de instrumento para registrar um conjunto de interações do usuário. O que é ainda mais grande é que os instrumentos geram o código JavaScript de automação da interface do usuário que é necessário para reproduzir as interações registradas. É assim que você pode experimentá-lo por si mesmo.
em instrumentos e com o instrumento de automação selecionado, procure o botão de gravação na parte inferior da janela.
> 
Se você clicar no botão de gravação, os instrumentos iniciarão uma sessão de gravação conforme mostrado na captura de tela a seguir.
Instrumentos lançará sua aplicação no simulador do iOS e poderá interagir com ele. Os instrumentos gerarão um roteiro com base em suas interações em tempo real. De uma chance. Gire o simulador do iOS, toque em locais aleatórios, faça um gesto deslizante, etc. É uma maneira muito útil de ajudar a explorar as possibilidades da automação da interface do usuário.
Evite o código monolítico
Como você pode prever, se continuarmos adicionando mais testes para o teste Arquivo que criamos com o mesmo método, será difícil manter. O que podemos fazer para evitar que isso aconteça? Em meus testes, faço duas coisas para resolver este problema:
- Um teste para uma função: Isso implica que os testes que escrevemos devem se concentrar em uma peça específica de funcionalidade. Eu vou até mesmo dar um nome apropriado, como
testEmptyInputField. - Agrupe os testes relacionados em um arquivo: agrupar testes relacionados ao mesmo arquivo. Isso mantém o código em um arquivo gerenciável. Isso também facilita testar as partes da funcionalidade separadamente executando os testes em um arquivo específico. Além disso, você pode criar um script mestre no qual você chamar as funções ou testes agrupados em outros arquivos de teste.
No seguinte fragmento de código, importamos um arquivo JavaScript e isso Funções nesse arquivo JavaScript estão disponíveis para nós.
#import "OtherTests.js”
Conclusão
Neste tutorial, você aprendeu o valor de Testes de nível superior e como a automação da UI pode ajudar a preencher esse vácuo. É outra ferramenta em sua caixa de ferramentas para ajudar a garantir que você envie aplicativos confiáveis e robustos.