test: 🚨 add tests

Author: maxbarsukov

test/algo/lagrange3_interpolation_test.exs

@@ -0,0 +1,39 @@
+defmodule InterpolationApp.Algo.Lagrange3InterpolationTest do
+  @moduledoc """
+  Testing InterpolationApp.Algo.Lagrange3Interpolation
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Algo.Lagrange3Interpolation, as: Algo
+
+  describe "get_name/0" do
+    test "returns correct name" do
+      assert Algo.get_name() == "Интерполяционный многочлен Лагранжа для 3 точек"
+    end
+  end
+
+  describe "get_enough_points_count/0" do
+    test "returns correct enough points count" do
+      assert Algo.get_enough_points_count() == 3
+    end
+  end
+
+  describe "interpolate/2" do
+    test "calculates correct interpolation for 3 points" do
+      points = [{1, 1}, {2, 4}, {3, 9}]
+      point = Algo.interpolate(points, 2.5)
+
+      assert point == {2.5, 6.25}
+    end
+
+    test "interpolation returns a tuple {x, y} with x same as input" do
+      ptest x: float(), p1: float(), p2: float(), p3: float() do
+        points = [{1, p1}, {2, p2}, {3, p3}]
+        {result_x, _} = Algo.interpolate(points, x)
+        result_x == x
+      end
+    end
+  end
+end

test/algo/lagrange4_interpolation_test.exs

@@ -0,0 +1,39 @@
+defmodule InterpolationApp.Algo.Lagrange4InterpolationTest do
+  @moduledoc """
+  Testing InterpolationApp.Algo.Lagrange4Interpolation
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Algo.Lagrange4Interpolation, as: Algo
+
+  describe "get_name/0" do
+    test "returns correct name" do
+      assert Algo.get_name() == "Интерполяционный многочлен Лагранжа для 4 точек"
+    end
+  end
+
+  describe "get_enough_points_count/0" do
+    test "returns correct enough points count" do
+      assert Algo.get_enough_points_count() == 4
+    end
+  end
+
+  describe "interpolate/2" do
+    test "calculates correct interpolation for 4 points" do
+      points = [{1, 1}, {2, 4}, {3, 9}, {4, 16}]
+      point = Algo.interpolate(points, 2.5)
+
+      assert point == {2.5, 6.25}
+    end
+
+    test "interpolation with 4 points returns a tuple {x, y} where x matches input" do
+      ptest x: float(), p1: float(), p2: float(), p3: float(), p4: float() do
+        points = [{1, p1}, {2, p2}, {3, p3}, {4, p4}]
+        {result_x, _} = Algo.interpolate(points, x)
+        result_x == x
+      end
+    end
+  end
+end

test/algo/linear_interpolation_test.exs

@@ -0,0 +1,39 @@
+defmodule InterpolationApp.Algo.LinearInterpolationTest do
+  @moduledoc """
+  Testing InterpolationApp.Algo.LinearInterpolation
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Algo.LinearInterpolation, as: Algo
+
+  describe "get_name/0" do
+    test "returns correct name" do
+      assert Algo.get_name() == "Линейная интерполяция"
+    end
+  end
+
+  describe "get_enough_points_count/0" do
+    test "returns correct enough points count" do
+      assert Algo.get_enough_points_count() == 2
+    end
+  end
+
+  describe "interpolate/2" do
+    test "calculates correct linear interpolation for 2 points" do
+      points = [{1, 2}, {2, 4}]
+      point = Algo.interpolate(points, 1.5)
+
+      assert point == {1.5, 3.0}
+    end
+
+    test "linear interpolation returns tuple {x, y} with x as input" do
+      ptest x: float(), p1: float(), p2: float() do
+        points = [{1, p1}, {2, p2}]
+        {result_x, _} = Algo.interpolate(points, x)
+        result_x == x
+      end
+    end
+  end
+end

test/algo/newton_interpolation_test.exs

@@ -0,0 +1,39 @@
+defmodule InterpolationApp.Algo.NewtonInterpolationTest do
+  @moduledoc """
+  Testing InterpolationApp.Algo.NewtonInterpolation
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Algo.NewtonInterpolation, as: Algo
+
+  describe "get_name/0" do
+    test "returns correct name" do
+      assert Algo.get_name() == "Интерполяция по Ньютону"
+    end
+  end
+
+  describe "get_enough_points_count/0" do
+    test "returns correct enough points count" do
+      assert Algo.get_enough_points_count() == 2
+    end
+  end
+
+  describe "interpolate/2" do
+    test "calculates correct Newton interpolation for given points" do
+      points = [{1, 1}, {2, 4}, {3, 9}, {4, 16}, {5, 25}]
+      {x, y} = Algo.interpolate(points, 4.5)
+
+      assert x == 4.5 and y > 17 and y < 22
+    end
+
+    test "Newton interpolation returns {x, y} with x matching input" do
+      ptest x: float(), p1: float(), p2: float(), p3: float() do
+        points = [{1, p1}, {2, p2}, {3, p3}]
+        {result_x, _} = Algo.interpolate(points, x)
+        result_x == x
+      end
+    end
+  end
+end

test/cli/config_parser_test.exs

@@ -0,0 +1,59 @@
+defmodule InterpolationApp.CLI.ConfigParserTest do
+  @moduledoc """
+  Testing InterpolationApp.CLI.ConfigParser
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.CLI.ConfigParser
+
+  describe "parse_args/1" do
+    test "parses correct args" do
+      args = ["methods=linear,lagrange3", "step=0.5", "accuracy=3"]
+
+      assert ConfigParser.parse_args(args) ==
+               {:ok,
+                %{
+                  methods: [
+                    InterpolationApp.Algo.LinearInterpolation,
+                    InterpolationApp.Algo.Lagrange3Interpolation
+                  ],
+                  step: 0.5,
+                  accuracy: 3
+                }}
+    end
+
+    test "returns error for no args" do
+      assert match?({:error, _}, ConfigParser.parse_args([""]))
+    end
+
+    test "returns error for repetitive methods" do
+      args = ["methods=linear,linear,linear", "step=0.5", "accuracy=3"]
+      assert match?({:error, _}, ConfigParser.parse_args(args))
+    end
+
+    test "returns error for invalid methods" do
+      args = ["methods=invalid,method", "step=0.5", "accuracy=3"]
+      assert match?({:error, _}, ConfigParser.parse_args(args))
+    end
+
+    test "returns error for invalid step" do
+      args = ["methods=invalid,method", "step=-0.5", "accuracy=3"]
+      assert match?({:error, _}, ConfigParser.parse_args(args))
+    end
+
+    test "returns error for invalid accuracy" do
+      args = ["methods=invalid,method", "step=-0.5", "accuracy=3.2"]
+      assert match?({:error, _}, ConfigParser.parse_args(args))
+    end
+
+    test "accepts positive float step and integer accuracy" do
+      ptest step: float(min: 0.1), accuracy: int(min: 1) do
+        args = ["methods=linear", "step=#{step}", "accuracy=#{accuracy}"]
+        {:ok, config} = ConfigParser.parse_args(args)
+        config.step == step and config.accuracy == accuracy
+      end
+    end
+  end
+end

test/cli/printer_test.exs

@@ -0,0 +1,25 @@
+defmodule InterpolationApp.CLI.PrinterTest do
+  @moduledoc """
+  Testing InterpolationApp.CLI.Printer
+  """
+
+  use ExUnit.Case, async: true
+  import ExUnit.CaptureIO
+
+  alias InterpolationApp.CLI.Printer
+
+  describe "print/2" do
+    test "prints method and result in expected format" do
+      {:ok, pid} = Printer.start_link(%{step: 0.1, accuracy: 2})
+
+      assert capture_io([pid: pid], fn ->
+               GenServer.cast(
+                 pid,
+                 {:print, InterpolationApp.Algo.LinearInterpolation, [{0.0, 0.0}]}
+               )
+
+               :sys.get_state(pid)
+             end) =~ ""
+    end
+  end
+end

test/utils/input_validator_test.exs

@@ -0,0 +1,32 @@
+defmodule InterpolationApp.Utils.InputValidatorTest do
+  @moduledoc """
+  Testing InterpolationApp.Utils.InputValidator
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Utils.InputValidator
+
+  describe "validate_input/1" do
+    test "validates correct input format" do
+      assert InputValidator.validate_input("1.0;2.0") == {:ok, {1.0, 2.0}}
+    end
+
+    test "returns error for non-numeric input" do
+      assert InputValidator.validate_input("a;b") == {:error, "Координаты должны быть числами"}
+    end
+
+    test "returns error for incorrect format" do
+      assert InputValidator.validate_input("1.0") == {:error, "У точки должны быть координаты"}
+    end
+
+    test "validates that input coordinates are numeric" do
+      ptest x: float(), y: float() do
+        input = "#{x};#{y}"
+        {:ok, {parsed_x, parsed_y}} = InputValidator.validate_input(input)
+        parsed_x == x and parsed_y == y
+      end
+    end
+  end
+end

test/utils/point_generator_test.exs

@@ -0,0 +1,27 @@
+defmodule InterpolationApp.Utils.PointGeneratorTest do
+  @moduledoc """
+  Testing InterpolationApp.Utils.PointGenerator
+  """
+
+  use ExUnit.Case, async: true
+  use Quixir
+
+  alias InterpolationApp.Utils.PointGenerator
+
+  describe "generate/2" do
+    test "generates points with correct step between given points" do
+      points = [{1, 1}, {3, 3}]
+      result = PointGenerator.generate(points, 0.5)
+      expected = [1.0, 1.5, 2.0, 2.5, 3.0, 3.5]
+      assert result == expected
+    end
+
+    test "generates intermediate points within the start and end points" do
+      ptest start: float(), finish: float(), step: float(min: 0.1, max: 1.0) do
+        points = [{start, 0}, {finish, 0}]
+        result = PointGenerator.generate(points, step)
+        Enum.all?(result, fn x -> x >= start and x <= finish + step end)
+      end
+    end
+  end
+end