Commenting on the purpose of a file is reasonable, as it explaining why a piece of code works the way it does e.g. if an external constraint is in play. But explaining how in code comments is redundant if the code is well written and the functions and variables are well named.
function X(Y, Z){
if(Y){
foo();
}
if(Z){
bar();
}
}
X(true, false);
X(false, true);
X(true, true);
X(false, false);
This is an issue with many code coverage tools. The lines themselves have been executed, but not necessarily all program states.
if (foo) { setSomeState() }
At least with tools I'm familiar with, your coverage will be 100% if you have one test with 'foo = true'.
That means that you could have odd untested behavior if not executing 'setSomeState()' leaves something important unset.... but you'd have 100% coverage.
Of course in practice, 100% state coverage is really impossible to achieve.
Anyway, that amount of comment is alright for learning purposes but for an actual lengthy code base it would be a nightmare keeping all that updated. Comments are supposed to be used just for complicated/critical code, otherwise is just noise to be maintained.
# where I found your post http://webarcs.com/?open=27311
The advantage of unit testing modular code bases is that you don't have to test every program state, you just have to test every module state.
There is a huge difference in the feasibility of 100% code coverage if you need O(2^n) vs O(n) tests.
Even if your modules are highly coupled you should be able to mock away external dependencies and side-effects.
I don't think that's true with a capital T. Modules interact with each other. You can modularize, microize, or nanoize your application but the minimum subset of test-worthy states stays the same.
Except, as pointed out, there is no lack of coverage in my example. All lines are 'covered', and no line is left unexecuted. So by definition, there is no 'lack of coverage' from the perspective of lines. The key is to not think about 'coverage' as a metric on lines, and instead think of 'coverage' as a metric on program states. However, that's generally not what people think of when 'code coverage' is mentioned unless something specific like 'program space coverage' or 'code state coverage'.
Keep in mind that this can be really hard though since even very simple code can have a large state space.
Also, if you have a favorite tool that does program space coverage for node.js projects, it might be helpful to mention it here so that others can benefit. Most of the tools for node that I know are only line coverage.
My reasoning is as follows. Since evaluating coverage in terms of the state space of the program is hard, and no tools that I am aware of is actually calculating that coverage, tools that display coverage in terms of number of lines should not mislead by showing a percentage, and only focus on showing places with no coverage at all.
While in technical terms it seems like the same metric, I think it would encourage its users not to celebrate an arbitrary cap of 100% coverage, and be aware of what the tools can and cannot do.