value + tests

Author: shinnokdisengir

lib/astarte/core/generators/mapping/value.ex

@@ -24,13 +24,9 @@ defmodule Astarte.Core.Generators.Mapping.Value do
 
   alias Astarte.Core.Interface
   alias Astarte.Core.Mapping
-  alias Astarte.Core.Mapping.ValueType
 
   alias Astarte.Core.Generators.Mapping.ValueType, as: ValueTypeGenerator
 
-  alias Astarte.Common.Generators.DateTime, as: DateTimeGenerator
-  alias Astarte.Common.Generators.Timestamp, as: TimestampGenerator
-
   @doc """
   Generates a valid value based on interface
   """
@@ -76,11 +72,6 @@ defmodule Astarte.Core.Generators.Mapping.Value do
     |> map(&Enum.join(&1, "/"))
   end
 
-  defp endpoint_base(:individual, endpoint), do: endpoint
-
-  defp endpoint_base(:object, endpoint),
-    do: endpoint_manipulate(endpoint, fn list -> Enum.drop(list, -1) end)
-
   defp endpoint_postfix(endpoint), do: Regex.replace(~r/.*\//, endpoint, "")
 
   defp build_value(value_type), do: ValueTypeGenerator.value_from_type(value_type)
@@ -93,10 +84,32 @@ defmodule Astarte.Core.Generators.Mapping.Value do
     end
   end
 
-  defp endpoint_manipulate(endpoint, manipulate_fn) do
-    endpoint
-    |> String.split("/")
-    |> manipulate_fn.()
-    |> Enum.join("/")
-  end
+  @doc """
+  Returns true if `path` matches `endpoint` according to the given `aggregation`.
+  TODO: move to astarte_core
+  """
+  @spec path_matches_endpoint?(:individual | :object, String.t(), String.t()) :: boolean()
+  def path_matches_endpoint?(:individual, endpoint, path),
+    do:
+      path_matches_endpoint?(
+        endpoint |> Mapping.normalize_endpoint() |> String.split("/"),
+        path |> String.split("/")
+      )
+
+  def path_matches_endpoint?(:object, endpoint, path),
+    do:
+      path_matches_endpoint?(
+        endpoint |> Mapping.normalize_endpoint() |> String.split("/") |> Enum.drop(-1),
+        path |> String.split("/")
+      )
+
+  defp path_matches_endpoint?([], []), do: true
+
+  defp path_matches_endpoint?(["" | endpoints], [_ | paths]),
+    do: path_matches_endpoint?(endpoints, paths)
+
+  defp path_matches_endpoint?([same | endpoints], [same | paths]),
+    do: path_matches_endpoint?(endpoints, paths)
+
+  defp path_matches_endpoint?(_, _), do: false
 end

test/astarte/core/generators/mapping/value_test.exs

@@ -22,10 +22,8 @@ defmodule Astarte.Core.Generators.Mapping.ValueTest do
 
   alias Astarte.Core.Interface
   alias Astarte.Core.Mapping
-  alias Astarte.Core.Mapping.EndpointsAutomaton
 
   alias Astarte.Core.Generators.Interface, as: InterfaceGenerator
-  alias Astarte.Core.Generators.Mapping, as: MappingGenerator
   alias Astarte.Core.Generators.Mapping.Value, as: ValueGenerator
 
   @moduletag :value
@@ -121,98 +119,39 @@ defmodule Astarte.Core.Generators.Mapping.ValueTest do
     @describetag :success
     @describetag :ut
 
-    property "generates value based on interface" do
+    property "generates value based on interface (gen)" do
       gen = InterfaceGenerator.interface() |> ValueGenerator.value()
 
       check all value <- gen do
         assert %{path: _path, value: _value} = value
       end
     end
 
-    @tag :temp
-    property "generates values based on aggregation :object must have mapping endpoint = base_endpoint + postfix" do
-      gen all %Interface{mappings: mappings} = interface <-
-                InterfaceGenerator.interface(aggregation: :object),
-              %{path: path, value: value} <- ValueGenerator.value(interface) do
-        IO.inspect("Ciao")
+    property "generates value based on interface (struct)" do
+      check all interface <- InterfaceGenerator.interface(),
+                value <- ValueGenerator.value(interface) do
+        assert %{path: _path, value: _value} = value
+      end
+    end
 
-        for %Mapping{endpoint: endpoint} <- mappings do
-          IO.inspect(endpoint)
-        end
+    property "generates value must have mapping path matches endpoint" do
+      check all %Interface{mappings: mappings, aggregation: aggregation} = interface <-
+                  InterfaceGenerator.interface(),
+                %{path: path, value: _value} <- ValueGenerator.value(interface) do
+        assert Enum.any?(mappings, fn %Mapping{endpoint: endpoint} ->
+                 ValueGenerator.path_matches_endpoint?(aggregation, endpoint, path)
+               end)
       end
     end
 
     property "generates values based on aggregation :object must have postfix different from other fields" do
       gen = InterfaceGenerator.interface(aggregation: :object) |> ValueGenerator.value()
 
       check all %{path: path, value: value} <- gen do
-        endpoint_postfix = path |> String.split("/") |> List.last()
-
-        for {postfix, _} <- value do
-          refute postfix == endpoint_postfix
-        end
+        last_seg = path |> String.split("/") |> List.last()
+        keys = Map.keys(value)
+        refute last_seg in keys
       end
     end
   end
-
-  # @doc false
-  # describe "value generator" do
-  #   @describetag :success
-  #   @describetag :ut
-
-  #   property "generates value based on interface" do
-  #     check all value <- InterfaceGenerator.interface() |> ValueGenerator.value() do
-  #       assert %{path: _path, value: _value} = value
-  #     end
-  #   end
-
-  #   property "generates valid value based on aggregation" do
-  #     check all aggregation <- one_of([:individual, :object]),
-  #               value <-
-  #                 InterfaceGenerator.interface(aggregation: aggregation)
-  #                 |> ValueGenerator.value() do
-  #       assert valid?(aggregation, value)
-  #     end
-  #   end
-
-  #   property "generates values for the correct endpoint for :individual interfaces" do
-  #     check all interface <- InterfaceGenerator.interface(aggregation: :individual),
-  #               %{path: path, value: value} <- ValueGenerator.value(interface) do
-  #       assert valid_value_for_path?(interface, path, value)
-  #     end
-  #   end
-
-  #   # property "check if path matches at least one endpoint considering aggregation" do
-  #   #   check all aggregation <- one_of([:individual, :object]),
-  #   #             interface_type <- InterfaceGenerator.type(),
-  #   #             mappings <-
-  #   #               MappingGenerator.mapping(interface_type: interface_type)
-  #   #               |> list_of(min_length: 1, max_length: 10),
-  #   #             %{path: path} <-
-  #   #               InterfaceGenerator.interface(
-  #   #                 type: interface_type,
-  #   #                 aggregation: aggregation,
-  #   #                 mappings: mappings
-  #   #               )
-  #   #               |> ValueGenerator.value() do
-  #   #     assert Enum.any?(mappings, fn %Mapping{endpoint: endpoint} ->
-  #   #              path_matches_endpoint?(aggregation, path, endpoint)
-  #   #            end)
-  #   #   end
-  #   # end
-
-  #   property "check field is present in object field (aggregation :object)" do
-  #     check all %{mappings: mappings} = interface <-
-  #                 InterfaceGenerator.interface(aggregation: :object),
-  #               %{value: value} <- ValueGenerator.value(interface),
-  #               endpoints =
-  #                 mappings
-  #                 |> Enum.map(fn %Mapping{endpoint: endpoint} ->
-  #                   Regex.replace(~r"^.*/", endpoint, "")
-  #                 end),
-  #               fields = value |> Enum.map(fn {field, _} -> field end) do
-  #       assert Enum.all?(fields, &(&1 in endpoints))
-  #     end
-  #   end
-  # end
 end