Primeiros passos com Jasmine

Hoje é um bom momento para ser um desenvolvedor em JavaScriptPode-se dizer que é até empolgante, pois as tecnologias que o envolvem amadureceram bastante, os navegadores estão mais padronizados e a cada dia surgem mais novidades para brincar e experimentar.
JavaScript é uma linguagem estabelecida e a web é a plataforma principal hoje, onde vimos o surgimento de aplicativos de página única, a proliferação de frameworks MVC como AngularJS ou Backbone.js, usando JavaScript do lado do servidor com Node.js e até mesmo aplicativos móveis criados exclusivamente usando HTML, CSS Y JavaScript com tecnologias como PhoneGap.
Desde o seu início humilde, o JavaScript tem se encarregado de servir como uma linguagem para manipular os dados e validá-los nos formulários em HTML e atualmente é usado para construir aplicativos poderosos que podemos ver na web. Vendo isso, pode-se dizer que JavaScript Percorreu um longo caminho, assim como as ferramentas que surgiram para garantir que tenhamos a mesma qualidade como se estivéssemos noutras línguas.
Uma dessas ferramentas é Jasmim, que nada mais é do que uma estrutura de desenvolvimento orientada ao comportamento e que nos permite criar testes de unidade automatizados para a linguagem de programação JavaScript. Antes de entrarmos totalmente com esta ferramenta, vamos ver os antecedentes que levaram ao seu desenvolvimento, bem como os principais conceitos para entender como ela funciona JavaScript.
Hoje ninguém duvida do poder de JavaScriptNo entanto, existem complicações ao trabalhar no lado do cliente e uma das razões óbvias é que não podemos controlar seu ambiente de execução. No servidor, não temos esse problema, pois podemos executar uma versão específica do Node.js mas, no caso do navegador da web, não podemos dizer ao usuário para usar uma versão específica de cromada ou Raposa de fogo.
A linguagem JavaScript é definido sob as especificações ECMAScript portanto, cada navegador pode ter sua própria implementação do ambiente para executá-lo, fazendo com que haja pequenas diferenças ou bugs entre eles. Cada objeto de JavaScript é mutável, então não temos nenhum tipo de controle para evitar que um módulo sobrescreva partes de outros, para ilustrar isso, vamos dar uma olhada em um pequeno segmento de código onde podemos ver como é fácil sobrescrever a função global console.log:

 console.log ('teste'); console.log = 'quebrar'; console.log ('teste');

Vamos ver a resposta por console, onde podemos ver claramente o erro, já que substituímos a função:

Esta forma de ser del lenguaje fue una decisión que se tomó en el diseño del mismo, ya que permitía a los desarrolladores agregar funcionalidades faltantes al mismo, pero dado esta versatilidad es relativamente más fácil cometer errores, incluso una versión más reciente del lenguaje introdujo la Função Object.seal o que impediu isso, mas seu suporte se estendeu apenas a alguns navegadores.
Outro problema que apresentamos JavaScript é o tratamento de tipos, em outras linguagens, uma expressão como '1' + 1 provavelmente gerará um erro, mas em JavaScript isso resultaria em 11. Isso pode levar a alguns problemas difíceis de encontrar, por exemplo, suponha que temos o seguinte:

 var a = 1, b = '5', c = 4, d = 2; resultado var = a + b + c * d; console.log (resultado);

Vamos ver a resposta por meio do console quando executamos nosso código no navegador:

Como podemos ver, o resultado foi uma string, portanto, se estivéssemos esperando um número em uma função ou rotina especial, isso pode causar um problema e encontrar esse erro pode significar perder algumas horas do nosso precioso tempo de desenvolvimento.
É importante mencionar que os pontos que acabamos de mencionar não são uma razão para não usar JavaScriptÉ simplesmente para ver onde tem algumas fragilidades mas isso não quer dizer que seja uma linguagem imprópria, podemos até assegurar que as possibilidades que ela nos apresenta são infinitas em termos de desenvolvimento de aplicações e o que é melhor, ainda temos ferramentas que nós eles ajudarão com as melhores práticas do mesmo.
Como mencionamos, Jasmim É um pequeno framework que nos ajuda com nossos testes de unidade dentro de nossos desenvolvimentos e que usa a filosofia de desenvolvimento orientado ao comportamento que explicaremos mais tarde, mas antes de continuar vamos ver um conceito importante que é que eles são testes de unidade.
Testes de unidadeAs testes de unidade São trechos de código que testam as funcionalidades das unidades do código de nossa aplicação, que no início desse caminho o desenvolvedor ficou com uma filosofia tradicional que focava no desenvolvimento orientado a testes ao invés de orientado a comportamento.
É por isso que os criadores de Jasmim eles reestruturam essa forma tradicional de teste, em que o desenvolvedor ficava sem uma imagem clara de por onde começar no processo de teste, sem saber o que testar e quão grande um módulo de teste poderia ser ou mesmo como eles chamariam um desses testes . Por exemplo, se usarmos a filosofia de Jasmim Para realizar os testes, suponha que temos um tocador de música que terá os seguintes critérios de aceitação: Dado o tocador, quando uma música é pausada o tocador deve indicar que a música foi pausada.
Portanto, podemos pegar o critério e dividi-lo da seguinte maneira:

• Dado (um contexto inicial)
• Quando (o evento ocorre)
• Então (uma ação é realizada)

Jasmim nos permite traduzir o acima em um código que será escrito de forma a refletir os valores de nosso aplicativo sem problemas, que pode ser parecido com este:

 describe ("Player", function () {describe ("Quando a música está em pausa", function () {it ("Deve indicar que a música está em pausa", function () {});});});

Como podemos ver, nossos critérios foram transferidos para Jasmim sem muitos problemas, onde podemos dizer que cada critério é traduzido em um teste de unidade.
Já poderíamos dar uma olhada em como Jasmim ele lida com os critérios e os traduz em sua sintaxe, criando os testes de unidade para ele, mas, para chegar lá, vamos primeiro ver como obter a estrutura primeiro. Para fazer isso, vamos para a página do projeto e baixamos:

PROLONGAR

Ao descompactá-lo devemos ir para a pasta dist, lá encontraremos todas as distribuições de Jasmim até o momento, onde começar a usá-lo devemos selecionar a distribuição que queremos, de preferência a mais recente e descompactá-la na pasta do nosso projeto, entrar na pasta e executar o arquivo SpecRunner.html:

Jasmim Inclui por padrão alguns exemplos de alguns testes de unidade, onde o arquivo SpecRunner.html é responsável por vincular o código Jasmine que inclui os arquivos fonte e os arquivos para teste, vamos ver seu conteúdo:

 Jasmine Spec Runner v2.2.0 

Como podemos ver, é bastante simples e nos permite definir uma estrutura de base para nossos testes, dando-nos uma ajuda sobre por onde começar neste mundo de testes unitários. Nem é preciso dizer que é uma boa ideia dar uma olhada no código de nossa distribuição de Jasmim para nos familiarizarmos com o seu funcionamento.
É importante mencionar que Jasmim não apenas limitado ao código escrito com JavaScript puro, podemos testar os aplicativos construídos com Backbone.js ou AngularJS, mesmo sua versatilidade vai muito além e nos permite realizar testes do lado do servidor, caso estejamos usando Node.js.
RecomendaçãoJasmim É um framework que nos ajuda muito na forma de testes unitários, porém os conceitos nele utilizados não são tão simples, ele é suportado por certas práticas avançadas de JavaScript como gerar o HTML usando a função createDom () para inserir os elementos nele, para citar algumas dessas características, por isso recomendamos dar uma olhada na documentação do JavaScript estar muito mais preparado para tutoriais futuros.
Com isso terminamos este tutorial, onde poderíamos dar nossos primeiros passos com Jasmim, percorrendo um pouco a motivação de criar ferramentas para testar JavaScript e como o desenvolvimento orientado para o comportamento nos ajuda a criar melhores testes, também vendo como Jasmim é uma estrutura bastante flexível para teste, permitindo-nos usar a mesma instância para testar todos os tipos de código em JavaScript em nossas aplicações.