Esta é uma pergunta sobre como trabalhar em equipe.
Recentemente, trabalhei no meu primeiro projeto de programação maior (~ 80 classes, Java) com uma equipe de 6 pessoas, embora apenas quatro de nós estivéssemos trabalhando continuamente no código. Distribuímos o trabalho a ser feito desde o início e, em algum momento, eu precisei chamar um método que ainda não foi implementado por um dos meus co-programadores. Como é a maneira recomendada de lidar com isso?
Opções que eu vi, embora eu realmente não goste de nenhuma delas:
Escrevendo para mim mesmo
//TODOe revisitando essa linha de código posteriormente para verificar se o método foi implementado nesse meio tempo.Pedir ao membro da equipe correspondente para implementar isso agora .
Lançar um runtimeException personalizado com uma descrição clara do que ainda não foi implementado. (Pelo menos, não precisamos procurar por muito tempo para descobrir o que está faltando)
Adicionando o método necessário à sua classe e escrevendo-os
//TODOno corpo da mensagem, possivelmente também envie uma mensagem rápida sobre essa alteração. (Agora não é mais problema meu, mas isso pode causar conflitos irritantes de mesclagem se eles estiverem trabalhando nesse método nesse meio tempo)Definir classes ou interfaces abstratas para tudo antes de realmente escrever o código que faz o trabalho. (Não funcionou muito bem porque essas interfaces eram frequentemente alteradas)
Respostas:
É uma pergunta interessante e a resposta pode ser mais fácil do que você pensa.
Simplificando, escreva testes que validem suas suposições. Não importa se você faz a implementação ou seus colegas programadores
A resposta longa.
Qualquer uma das opções listadas é um pouco passiva e exige que você volte e revise o código (se houver), mais cedo ou mais tarde.
Para atingir um nível suficiente de teste, sugiro que você dê uma olhada em duas disciplinas.
TDD - desenvolvimento orientado a testes - isso garantirá que você descreva sua intenção e a teste suficientemente. Também oferece a possibilidade de zombar ou falsificar métodos e classes (também usando interfaces) que ainda não foram implementadas. O código e os testes ainda serão compilados e permitirão que você teste seu próprio código isoladamente do código de seus colegas programadores. (consulte: https://en.wikipedia.org/wiki/Test-driven_development )
ATDD - desenvolvimento orientado a teste de aceitação - isso criará um loop externo (em torno do loop TDD) que ajuda você a testar o recurso como um todo. Esses testes só ficarão verdes quando todo o recurso for implementado, fornecendo um indicador automático quando seus colegas concluírem o trabalho. Muito legal se você me perguntar.
Advertência: No seu caso, eu escreveria apenas testes de aceitação simples e não tentaria atrair muito do lado dos negócios, pois seria demais para começar. Escreva testes simples de integração que reúnam todas as partes do sistema que o recurso exige. Isso é tudo o que é necessário
Isso permitirá que você coloque seu código em um pipeline de integração contínua e produza uma implementação altamente confiável.
Se você quiser se aprofundar nesse tópico, verifique os seguintes links:
fonte
Peça stubs.
Ou escreva você mesmo. De qualquer forma, você e seus colegas de trabalho precisam concordar com as interfaces e como elas devem ser usadas. Esse contrato precisa ser relativamente solidificado para que você possa desenvolver contra stubs - para não mencionar, para criar suas próprias zombarias para os testes de unidade ...
fonte
Na sua situação, eu conversaria com o membro da equipe responsável por essa função. Pode ser que eles estejam em posição de priorizar o desenvolvimento dessa função, para que você possa começar a usá-la mais cedo.
Eu evitaria sua quarta opção. Você escreveu todo o seu código e, como diz, não o considera mais seu problema. Seu colega então escreve a implementação da função e não considera mais o problema. Quem realmente vai testar se o código que VOCÊ escreveu funciona corretamente?
fonte