Comments on SandyWalsh.com: The Pain of Unit Tests and Dynamically Typed Langu...

This is a good point Sandy. It's also a proble...

2011-11-29T16:17:55.485-04:00

This is a good point Sandy. It's also a problem when you are doing funky RPC casts that are no longer sending the correct type of data the end function is expecting (ran into this today in OpenStack).

Another supporting point for static type-checking is that programmers are lazy and don't always go out of their way to inspect for everything that is calling a function. If someone is reviewing code, it's hard to go behind everyone and make sure they do this.

@ryan, I agree, but I think you're missing the...

2011-09-30T11:42:53.236-03:00

@ryan, I agree, but I think you're missing the point of my post.

Testing the inputs and return types on a unit testing basis won't solve the problem when you're using a dynamically typed language. You *have* to do integration testing.

Otherwise, your tests will pass, but the program will fail in the field (since the inputs and/or output no longer match).

The contract of compute() includes both it's r...

2011-09-30T10:11:28.651-03:00

The contract of compute() includes both it's return type(s), and what it does. In a statically typed world, we're used to leaning on the compiler for the prior, and using unit tests to enforce the latter. But in a dynamically typed world, we need to explicitly test return types in our contract tests as well.

Arguably, integration tests are a crutch for when you're not completely testing the contract of a service/interface that your other unit tests are mocking/stubbing.

(In the real world, the crutch is often useful or necessary, but I still like to lean on it as little as possible.)

@robinbb ... heh, well let's not go crazy now....

2011-09-01T21:29:34.071-03:00

@robinbb ... heh, well let's not go crazy now. I thought you would have enjoyed by little subtle dig of

# 100 lines of C

:)

There a good summary of hybrid languages here: http://en.wikipedia.org/wiki/Type_system#Combinations_of_dynamic_and_static_typing

When you wrote "What does this mean for us Py...

2011-09-01T21:18:12.250-03:00

When you wrote "What does this mean for us Python/Ruby/PHP developers?" I thought that you were going to continue in another direction entirely. "Switch to a statically typed language" would have been another way to go. :-)

Is there a statically typed Python-like language?

I agree. It doesn't happen that often, but whe...

2011-08-31T20:00:34.010-03:00

I agree. It doesn't happen that often, but when it does the first thing I think is "Why didn't the tests catch that?"

From the feedback I've been getting on this article I think people define the term "unit test" very loosely. They're willing to call outside of the function being tested and don't strictly mock everything external.

I view that as an integration test. A test that spans multiple components. It sounds like you're in the "willing to span components" camp as well by your assumption that the compute tests should have gone red. But they wouldn't have if all external methods are mocked.

And that's not to say your approach is wrong. Perhaps I'm just overly strict on what I view as a unit test? In other languages it would never be a problem.

I think what I'm trying to do is find the boundary between a pure unit test and a full-on integration test (which I fear creating).

In the process it seems I'm learning more about how other people approach "unit" testing.

I don't really expect this to bite me very oft...

2011-08-31T19:31:19.018-03:00

I don't really expect this to bite me very often. The return type is part of the contract, and everyone knows it even if the interpreter doesn't know it, so whoever changed compute() would have known that they needed to inspect the code that calls it.

Also, wouldn't the unit tests of compute() have gone red when they made this change, since the unit tests insisted that the return type be numeric? So they would have had to change those unit tests to no longer insist on that, which certainly should have clued them in that what they are doing is changing something that someone else relies on.

But yeah, static type-checking is great when it is great.