TDD para um Communicator Dispositivo

Question

Eu estive lendo sobre TDD, e gostaria de usá-lo para o meu próximo projeto, mas eu não tenho certeza de como estruturar as minhas aulas com este novo paradigma. A linguagem que eu gostaria de uso é Java, embora o problema não é específico do idioma realmente.

O projeto

Eu tenho algumas peças de hardware que vêm com uma interface ASCII-over-RS232. I pode emitir comandos simples, e obter respostas simples, e controlá-los como se de seus painéis frontais. Cada um tem uma sintaxe um pouco diferente e muito diferentes conjuntos de comandos. Meu objetivo é criar uma abstração / Interface para que eu possa controlá-los todos através de uma GUI e / ou chamadas de procedimento remoto.

O Problema

Eu acredito que o primeiro passo é criar uma classe abstrata (eu sou ruim em nomes, como sobre 'Communicator'?) Para implementar todas as coisas como Serial I / O, e depois criar uma subclasse para cada dispositivo. Tenho certeza de que vai ser um pouco mais complicado do que isso, mas isso é o núcleo da aplicação em minha mente.

Agora, para testes de unidade, eu não acho que eu realmente preciso do hardware real ou uma conexão serial. O que eu gostaria de fazer é entregar meus Comunicadores um InputStream e OutputStream (ou leitor e escritor) que poderiam ser de uma porta serial, arquivo, stdin / stdout, canalizada a partir de uma função de teste, seja qual for. Então, se eu apenas ter o construtor Communicator tomar aqueles como entradas? Se assim for, seria fácil colocar a responsabilidade de definir tudo em cima da estrutura de testes, mas para a coisa real, que faz a conexão real? Um construtor separado? A função de chamar o construtor de novo? A classe separada que é trabalho é 'conectar' o Communicator para os fluxos corretos de I / O?

Editar

Eu estava prestes a reescrever a seção de problema, a fim de obter respostas para a pergunta que eu pensei que eu estava perguntando, mas eu acho que eu percebi isso. Eu tinha (corretamente?) Identificaram duas áreas funcionais diferentes.

1) Tratar com a porta serial

2) que comunica com o dispositivo (entendendo seus comandos de saída & geradoras)

Há alguns meses atrás, eu teria combinado tudo em uma classe. Minha primeira idéia no sentido de romper com essa era passar apenas o IO córregos para a classe que compreende o dispositivo, e eu não conseguia descobrir o que seria, então, responsável por criar as correntes.

Depois de ter feito mais pesquisas sobre inversão de controle, eu acho que tenho um resposta. Tem uma interface separada e classe que resolver o problema # 1 e passá-lo para o construtor da classe (s?) Que resolver o problema # 2. Dessa forma, é fácil de testar tanto separadamente. # 1 conectando-se ao hardware real e permitindo que a estrutura de teste para fazer coisas diferentes. # 2 pode ser testada por ser dada uma simulação de # 1.

Isso soa razoável? Preciso compartilhar mais informações?

Answer 1

Com TDD, você deve deixe seu projeto emergir , começar pequeno, com passos de bebê e crescer o seu teste de aulas por teste, pouco a pouco.

esclarecidos: Comece com uma classe concreta, para enviar um comando, teste de unidade com um mock ou um topo. Quando ele vai trabalhar o suficiente (talvez não com todas as opções), testá-lo contra o seu dispositivo real, uma vez que, para validar a sua simulação / ramal / simulador.

Uma vez que a classe para o primeiro comando é operacional, começar a implementar um segundo comando, da mesma maneira: primeiro novamente o seu simulação / stub, em seguida, uma vez contra o dispositivo para validação. Agora, se você está vendo semelhanças entre suas duas classes, você pode refatorar ao seu design baseado classe abstrata - ou para algo diferente.

Answer 2

Desculpe por ser um pouco centric Linux ..

A minha maneira favorita de simular gadgets é a caráter gravação que simular o seu comportamento. Isto também lhe dá habilidades divertidas, como fornecendo uma interface ioctl () que faz com que se comportam dispositivo simulado de forma anormal.

Nesse ponto .. de testar para o mundo real, ele só importa qual dispositivo (s) que você realmente abrir, ler e escrever.

Não deve ser muito difícil de imitar o comportamento de seus gadgets .. parece que eles aceitam instruções muito básicas e retornar respostas muito básicas. Mais uma vez, um ioctl () simples poderia dizer o dispositivo simulado que o seu tempo a se comportar mal, assim você pode garantir que seu código está a lidar com tais eventos adequadamente. Por exemplo, falhar intencionalmente em cada instrução n'th, onde n é selecionado aleatoriamente sobre a chamada para ioctl ().

Answer 3

Depois de ver as suas edições eu acho que você está indo exatamente na direção certa. TDD tende a levá-lo para um projeto composto por turmas pequenas com uma responsabilidade bem definida. Também gostaria de aconselhamento eco tinkertim de -. Um simulador de dispositivo que você pode controlar e "provocar" a se comportar de maneiras diferentes é inestimável para testes