String validation with Regex and ExUnit

If your sample strings are constants, you could put them in a module attribute:

@sample_strings %{
  sample_str1: "test_string",
  sample_str2: "cz-dev",
  sample_str3: "new___cczdj",
  sample_str4: "czar,,,nic",
  ...
}

General comment on input_length_valid: there are only four functions that take a single boolean value and return a single boolean value (constant true, constant false, identity, and invert) - whenever you find yourself writing a case with booleans on both sides of the ->s, figure out which one of the four you have and remove the case.

In this case you have “invert” - so input_length_valid simplifies to not(String.length(inp) > 100) or even just String.length(inp) <= 100

As to the test itself, unless there are a LOT of cases in @sample_strings you may find a single test easier to write. For instance, this is a very simple approach:

defp regex_matches?(sample) do
  sample
  |> String.replace("_", "-")
  |> String.match?(~r/^(my-regex)$/)
end

test "sample strings match" do
  Enum.each(@sample_strings, fn {_label, sample} ->
    assert regex_matches?(sample)
    assert input_length_valid(sample)
  end)
end

One downside of this approach is that it will fail the test on the first string that doesn’t match; if you want to see all the failures in a single run you could accumulate them explicitly:

test "sample strings match" do
  failed_matches =
    Enum.reject(@sample_strings, fn {_label, sample} ->
      regex_matches?(sample)
    end)

  assert [] == failed_matches

  # similar for input_length_valid
end

The main thing I like to keep in mind when structuring asserts like these: what do I want to learn when one fails?

Hey Matt,
Thanks a lot for the feedback.
My goal is to provide a test bed for trying out regular expressions. I’m currently displaying the strings that fail either test with IO.inspect.

On another note, I was thinking of adding the length_check to the pipe in regex_matches?()/1; since it returns a binary I don’t think it’s a good idea since I have to short circuit the pipeline. Would you recommend a with statement?

 with   true   <- input_length_valid(sample),   
    (the crux) <- String.replace(sample, "_", "-"),  
        true   <- String.match?(~r/^(my-regex)$/)  do

Thank you very much for your guidance.

To be frank, I don’t understand the intent of either input_length_valid or the String.replace here since the inputs are literals in the file - so it’s hard to make specific recommendations.

You could use an = clause for the String.replace if you wanted to use with.

In my particular use case, the input strings should have less than 100 characters. I think you are correct that the replace statement is a preprocessing step and should not be part of the test. Thank you for putting that into perspective.

As an alternative to @al2o3cr’s excellent answer, you can just code-generate test cases for each value so you have one failing test for each value that doesn’t match well:

defmodule YourApp.YourModuleTest do
  use ExUnit.Case

  @values ["test_string", "cz-dev", "new___cczdj", "czar,,,nic"]
  @regex "your_regex_here"

  describe "value" do
    for value <- @values do
      test unquote(value) do
        value = unquote(value)
        value = String.replace(value, "_", "-")
        assert String.match?(value, @regex)
        assert input_length_valid(value)
      end
    end
  end
end

Or you can draw out the heavy guns and use property-based testing (with some limitations of the input values so they are not infinite).

Thanks a lot @dimitarvp.