TL; DR Preciso de ajuda na identificação de técnicas para simplificar o teste de unidade automatizado ao trabalhar em uma estrutura estável.
Fundo:
Atualmente, estou escrevendo um jogo no TypeScript e na estrutura da Phaser . A Phaser se descreve como uma estrutura de jogo HTML5 que tenta o mínimo possível para restringir a estrutura do seu código. Isso vem com algumas trocas, a saber, que existe um objeto de Deus Phaser.Game que permite acessar tudo: cache, física, estados do jogo e muito mais.
Esse estado torna muito difícil testar muitas funcionalidades, como o meu Tilemap. Vamos ver um exemplo:
Aqui estou testando se minhas camadas de mosaico estão ou não corretamente e posso identificar as paredes e criaturas no meu Tilemap:
export class TilemapTest extends tsUnit.TestClass {
constructor() {
super();
this.map = this.mapLoader.load("maze", this.manifest, this.mazeMapDefinition);
this.parameterizeUnitTest(this.isWall,
[
[{ x: 0, y: 0 }, true],
[{ x: 1, y: 1 }, false],
[{ x: 1, y: 0 }, true],
[{ x: 0, y: 1 }, true],
[{ x: 2, y: 0 }, false],
[{ x: 1, y: 3 }, false],
[{ x: 6, y: 3 }, false]
]);
this.parameterizeUnitTest(this.isCreature,
[
[{ x: 0, y: 0 }, false],
[{ x: 2, y: 0 }, false],
[{ x: 1, y: 3 }, true],
[{ x: 4, y: 1 }, false],
[{ x: 8, y: 1 }, true],
[{ x: 11, y: 2 }, false],
[{ x: 6, y: 3 }, false]
]);Não importa o que eu faça, assim que tento criar o mapa, a Phaser chama internamente seu cache, que é preenchido apenas durante o tempo de execução.
Não posso invocar esse teste sem carregar o jogo inteiro.
Uma solução complexa pode ser escrever um adaptador ou proxy que apenas construa o mapa quando precisarmos exibi-lo na tela. Ou eu mesmo poderia preencher o jogo carregando manualmente apenas os ativos necessários e, em seguida, usando-o apenas para a classe ou módulo de teste específico.
Eu escolhi o que considero uma solução mais pragmática, mas estranha para isso. Entre o carregamento do meu jogo e a execução real, eu calcei um TestStateque executa o teste com todos os ativos e dados em cache já carregados.
Isso é legal, porque eu posso testar todas as funcionalidades que eu quero, mas também não é legal, porque esse é um teste técnico de integração e nos perguntamos se eu não poderia apenas olhar para a tela e ver se os inimigos são exibidos. Na verdade, não, eles podem ter sido identificados erroneamente como um Item (já aconteceu uma vez) ou - posteriormente nos testes - eles podem não ter recebido eventos relacionados à sua morte.
A minha pergunta - é comum o shimming em um estado de teste como este? Existem abordagens melhores, especialmente no ambiente JavaScript, das quais não conheço?
Outro exemplo:
Ok, aqui está um exemplo mais concreto para ajudar a explicar o que está acontecendo:
export class Tilemap extends Phaser.Tilemap {
// layers is already defined in Phaser.Tilemap, so we use tilemapLayers instead.
private tilemapLayers: TilemapLayers = {};
// A TileMap can have any number of layers, but
// we're only concerned about the existence of two.
// The collidables layer has the information about where
// a Player or Enemy can move to, and where he cannot.
private CollidablesLayer = "Collidables";
// Triggers are map events, anything from loading
// an item, enemy, or object, to triggers that are activated
// when the player moves toward it.
private TriggersLayer = "Triggers";
private items: Array<Phaser.Sprite> = [];
private creatures: Array<Phaser.Sprite> = [];
private interactables: Array<ActivatableObject> = [];
private triggers: Array<Trigger> = [];
constructor(json: TilemapData) {
// First
super(json.game, json.key);
// Second
json.tilesets.forEach((tileset) => this.addTilesetImage(tileset.name, tileset.key), this);
json.tileLayers.forEach((layer) => {
this.tilemapLayers[layer.name] = this.createLayer(layer.name);
}, this);
// Third
this.identifyTriggers();
this.tilemapLayers[this.CollidablesLayer].resizeWorld();
this.setCollisionBetween(1, 2, true, this.CollidablesLayer);
}Eu construo meu Tilemap a partir de três partes:
- Os mapas
key - O
manifestdetalhamento de todos os ativos (planilhas e sprites) exigidos pelo mapa - A
mapDefinitionque descreve a estrutura e as camadas do tilemap.
Primeiro, devo chamar super para construir o Tilemap na Phaser. Essa é a parte que chama todas essas chamadas para o cache, enquanto tenta procurar os ativos reais e não apenas as chaves definidas no manifest.
Segundo, associo as folhas de mosaico e as camadas de mosaico ao Tilemap. Agora ele pode renderizar o mapa.
Terceiro, eu iterate através das minhas camadas e encontrar objetos especiais que eu quero extrusão a partir do mapa: Creatures, Items, Interactablese assim por diante. Eu crio e armazeno esses objetos para uso posterior.
Atualmente, ainda tenho uma API relativamente simples que permite encontrar, remover, atualizar essas entidades:
wallAt(at: TileCoordinates) {
var tile = this.getTile(at.x, at.y, this.CollidablesLayer);
return tile && tile.index != 0;
}
itemAt(at: TileCoordinates) {
return _.find(this.items, (item: Phaser.Sprite) => _.isEqual(this.toTileCoordinates(item), at));
}
interactableAt(at: TileCoordinates) {
return _.find(this.interactables, (object: ActivatableObject) => _.isEqual(this.toTileCoordinates(object), at));
}
creatureAt(at: TileCoordinates) {
return _.find(this.creatures, (creature: Phaser.Sprite) => _.isEqual(this.toTileCoordinates(creature), at));
}
triggerAt(at: TileCoordinates) {
return _.find(this.triggers, (trigger: Trigger) => _.isEqual(this.toTileCoordinates(trigger), at));
}
getTrigger(name: string) {
return _.find(this.triggers, { name: name });
}É essa funcionalidade que quero verificar. Se eu não adicionar as camadas ou os conjuntos de blocos, o mapa não será renderizado, mas talvez eu possa testá-lo. No entanto, mesmo chamar super (...) invoca uma lógica de estado ou de estado específico que não consigo isolar em meus testes.
new Tilemap(...)Phaser começa a cavar em seu cache. Eu teria que adiar isso, mas isso significa que meu Tilemap está em dois estados, um que não pode render-se adequadamente e o totalmente construído.