Maximum Sub-array Problem
I wanted to tackle the problem from a TDD standpoint


and


  I ended up with ~11 tests, although not all of them are probably required (some were me just trying to break things after the fact to prove to myself it was working).


You should look at other options for example QuickCheck (Haskell), but there apparently is a F# port [fscheck][1]. 
Basic idea is the quickcheck asserts some invariant of the output value of a function.

Or in the same vein but more simply, why not test the following cases:
For each array with a length between 1 and 5 and whose each element is one of {-2, -1, 0, 1, 2}. 
It gives you tests in 10s of thousands tests, not several; 
and exhaustively searches the most interesting, albeit small, portion of the problem domain. 
You can generate and store the answers or can generate them on the fly.

This is the black box part.

For white box part you can check the internal invariants of the algorithm.
You can use Debug.Assert or whatever else your compiler gives you.

  if (bestSum &lt; 0 &amp;&amp; bestSum &lt; value)
  {
    bestSum = value;
    currentSum = value;
  }

...........

bestSum = Math.Max(currentSum, bestSum);


snippets are repetitive

So is value &gt; -1 * currentSum and value &lt;= -1 * currentSum.

Moreover, (currentSum + value) &gt; 0 is more readable than value &gt; -1 * currentSum.
Similarly (currentSum + value) &lt;= 0  is more readable than value &lt;= -1 * currentSum.
Also note there is another currentSum + value hidden in currentSum += value.

Compare 

if (value &lt; 0 &amp;&amp; value &gt; -1 * currentSum)
     currentSum += value;


and 

if (value &lt; 0 &amp;&amp; (currentSum + value) &gt; 0)
     currentSum = currentSum + value;


currentSum is called currentSum but most of the time holds the previousSum.
This isn't semantic nitpicking. Correct naming is valuable in itself, 
but this also prevents you from bestSum = Math.Max(currentSum, bestSum); 
right at the end of the for loop. Which is an important loop invariant.
That is expressed succinctly in a single site. 
As it is, this is provided by the two bestSum= assignments mentioned above.
But it requires the reader to reason (rightly or wrongly) third clause and the conspicuously missing 4th (else) clause in the conditional analysis of the code does not break the invariant (that is bestSum remains the maximal sub-array sum).

if (bestSum &lt; 0 &amp;&amp; means we only encountered negative numbers and this is a special case and should be handled lower than the main cases. Or better yet do not handle this case separately.


  Is there some extraneous logic in here that could be refactored away?


I think your algorithm is not fundamentally different Kadane's algorithm, unless there is a missed case in the confusing conditional.