Complexidade Ciclomática

Em 1976 Thomas J. McCabe escreveu um artigo com o título: A Complexity Measure, onde ele desenvolveu uma técnica para “medir” a complexidade de um software que ele chamou de complexidade ciclomática.

A complexidade ciclomática é a quantidade de “caminhos” independentes que um sistema pode seguir.

Medindo a complexidade de um código

De acordo com o artigo original de MacCabe, esta complexidade não deveria passar de 10.

Para descobrir a complexidade de um código faça o seguinte:

• Adicione 1 ponto para a declaração/assinatura do método;
• Cada if, while, for, e case valem 1 ponto a mais na complexidade do seu código.

Desta forma temos abaixo um exemplo de método com complexidade ciclomática igual a 11, o que está além do limite recomendado, neste casos se possível, refatore o método.

// Complexidade ciclomática = 11
class Foo 
{
1   public function example() {
2       if ($a == $b) {
3           if ($a1 == $b1) {
                fiddle();
4           } elseif ($a2 == $b2) {
                fiddle();
            } else {
                fiddle();
            }
5       } elseif ($c == $d) {
6           while ($c == $d) {
                fiddle();
            }
7        } elseif ($e == $f) {
8           for ($n = 0; $n < $h; $n++) {
                fiddle();
            }
        } else {
            switch ($z) {
9               case 1:
                    fiddle();
                    break;
10              case 2:
                    fiddle();
                    break;
11              case 3:
                    fiddle();
                    break;
                default:
                    fiddle();
                    break;
            }
        }
    }
}

Em grandes trechos de código não será fácil descobrir a complexidade apenas olhando, para isso existem ferramentas que podem ajudar, como a PHPMD, que é muito útil em código legado, e JSHint para códigos JavaScript.

Abordagem para QAs ou Testers de software

Como citado lá no início deste artigo, a complexidade ciclomática é a quantidade de “caminhos” independentes que um sistema pode seguir, logo:

A complexidade ciclomática representa o número mínimo de testes que devem ser executados.

Imagine por exemplo, testar um sistema de login onde o usuário só consiga entrar se for maior de 18 anos, o resultado seria verdadeiro para a tentativa de logar de um usuário maior de idade, e falso para um usuário menor de idade, sendo assim temos uma complexidade 2, será necessário o teste de no mínimo dois casos.

Saber o valor exato da complexidade de um sistema nos levaria direto para a escrita dos casos de testes de caixa branca, testes onde o QA ou Tester conhecem a estrutura interna da aplicação, e nos pouparia muito tempo e consequentemente recursos financeiros. Complexidade ciclomática faz parte dos testes de caixa branca.

Conclusão

Quanto mais estruturas de decisão maior a complexidade de um sistema, o que certamente gerará altos custos de manutenção, muitas vezes impossibilitando a cobertura de testes de um software.

A verdade é que em um código muito complexo torna-se impossível garantir que todos os testes possíveis serão executados, sendo assim é quase certo que em algum momento ocorrerão falhas, os famigerados “bugs”.

Estratégias de refatoração devem ser adotadas para minimizar a complexidade em sistemas, uma das abordagens para resolver o problema de complexidade é aplicar o padrão de projeto Strategy, adotar o TDD e técnicas de SOLID, etc.

Referência

A Complexity Measure. THOMAS J. McCABE. Acesso em 19 mar. 2020.