labelmaker/test/labelmaker_web/constants_test.exs

defmodule LabelmakerWeb.ConstantsTest do
  use ExUnit.Case, async: true
  alias LabelmakerWeb.Constants

  describe "colors/0" do
    test "returns list of valid colors" do
      colors = Constants.colors()
      assert is_list(colors)
      assert "black" in colors
      assert "white" in colors
      assert "red" in colors
      assert "blue" in colors
      assert "green" in colors
    end

    test "contains no duplicates" do
      colors = Constants.colors()
      assert length(colors) == length(Enum.uniq(colors))
    end
  end

  describe "fonts/0" do
    test "returns list of valid fonts" do
      fonts = Constants.fonts()
      assert is_list(fonts)
      assert "Helvetica" in fonts
      assert "Impact" in fonts
      assert "Georgia" in fonts
    end

    test "fonts are properly formatted" do
      fonts = Constants.fonts()
      # Should not contain -MS suffix
      refute "Comic-Sans-MS" in fonts
      # Should contain cleaned version
      assert "Comic Sans" in fonts
    end
  end

  describe "font_map/0" do
    test "returns map with font shortcuts" do
      font_map = Constants.font_map()
      assert is_map(font_map)
      assert font_map["h"] == "Helvetica"
      assert font_map["i"] == "Impact"
      assert font_map["cs"] == "Comic-Sans-MS"
    end

    test "includes full font names as keys" do
      font_map = Constants.font_map()
      assert font_map["helvetica"] == "Helvetica"
      assert font_map["impact"] == "Impact"
    end
  end

  describe "outlines/0" do
    test "returns list including 'none' and all colors" do
      outlines = Constants.outlines()
      assert "none" in outlines
      assert "black" in outlines
      assert "white" in outlines
    end
  end

  describe "sizes/0" do
    test "returns list of valid sizes as strings" do
      sizes = Constants.sizes()
      assert is_list(sizes)
      assert "16" in sizes
      assert "72" in sizes
      assert "128" in sizes
    end

    test "all sizes are strings" do
      sizes = Constants.sizes()
      assert Enum.all?(sizes, &is_binary/1)
    end

    test "sizes are in increments of 8" do
      sizes = Constants.sizes()
      integers = Enum.map(sizes, &String.to_integer/1)
      # Check that consecutive sizes differ by 8
      diffs =
        integers
        |> Enum.chunk_every(2, 1, :discard)
        |> Enum.map(fn [a, b] -> b - a end)

      assert Enum.all?(diffs, &(&1 == 8))
    end
  end

  describe "defaults/0" do
    test "returns map with default values" do
      defaults = Constants.defaults()
      assert is_map(defaults)
      assert defaults.color == "black"
      assert defaults.font == "Helvetica"
      assert defaults.size == "72"
      assert defaults.outline == "white"
    end

    test "includes all required keys" do
      defaults = Constants.defaults()
      assert Map.has_key?(defaults, :color)
      assert Map.has_key?(defaults, :font)
      assert Map.has_key?(defaults, :size)
      assert Map.has_key?(defaults, :outline)
      assert Map.has_key?(defaults, :label)
      assert Map.has_key?(defaults, :align)
      assert Map.has_key?(defaults, :width)
      assert Map.has_key?(defaults, :height)
    end
  end

  describe "form_defaults/0" do
    test "returns map with form-specific defaults" do
      form_defaults = Constants.form_defaults()
      assert is_map(form_defaults)
      assert form_defaults.sizing == "font"
      assert form_defaults.preview_background == "r"
    end
  end

  describe "permitted_alignments/0" do
    test "returns list of valid alignments" do
      alignments = Constants.permitted_alignments()
      assert "left" in alignments
      assert "center" in alignments
      assert "right" in alignments
    end
  end

  describe "permitted_gravity/0" do
    test "returns list of ImageMagick gravity values" do
      gravity = Constants.permitted_gravity()
      assert "west" in gravity
      assert "center" in gravity
      assert "east" in gravity
    end
  end

  describe "sizing_values/0" do
    test "returns valid sizing modes" do
      values = Constants.sizing_values()
      assert "font" in values
      assert "wxh" in values
    end
  end

  describe "max_label_length/0" do
    test "returns positive integer" do
      max_length = Constants.max_label_length()
      assert is_integer(max_length)
      assert max_length > 0
    end
  end

  describe "max_width/0 and max_height/0" do
    test "returns positive integers" do
      assert is_integer(Constants.max_width())
      assert is_integer(Constants.max_height())
      assert Constants.max_width() > 0
      assert Constants.max_height() > 0
    end
  end

  describe "rows_min/0 and rows_max/0" do
    test "returns valid range" do
      assert Constants.rows_min() > 0
      assert Constants.rows_max() > Constants.rows_min()
    end
  end

  describe "danger/0" do
    test "returns hex color code" do
      danger = Constants.danger()
      assert String.starts_with?(danger, "#")
    end
  end

  describe "permitted_keys/0" do
    test "returns list of all permitted parameter keys" do
      keys = Constants.permitted_keys()
      assert is_list(keys)
      assert "color" in keys
      assert "font" in keys
      assert "size" in keys
      assert "label" in keys
    end

    test "all keys are strings" do
      keys = Constants.permitted_keys()
      assert Enum.all?(keys, &is_binary/1)
    end
  end
end