259 lines
9.7 KiB
Elixir
259 lines
9.7 KiB
Elixir
defmodule ParserTest do
|
|
use ExUnit.Case, async: true
|
|
use ExUnitProperties
|
|
|
|
describe "split_packet/1" do
|
|
property "returns {:ok, [sender, path, data]} for valid packets" do
|
|
check all sender <- StreamData.string(:alphanumeric, min_length: 1),
|
|
path <- StreamData.string(:alphanumeric, min_length: 1),
|
|
data <- StreamData.string(:printable, min_length: 1) do
|
|
packet = sender <> ">" <> path <> ":" <> data
|
|
assert {:ok, [^sender, ^path, ^data]} = Parser.split_packet(packet)
|
|
end
|
|
end
|
|
|
|
property "returns error for invalid packets" do
|
|
check all s <- StreamData.string(:printable, max_length: 10) do
|
|
bad = s <> s
|
|
assert match?({:error, _}, Parser.split_packet(bad))
|
|
end
|
|
end
|
|
|
|
test "returns error for missing > or :" do
|
|
assert match?({:error, _}, Parser.split_packet("senderpathdata"))
|
|
assert match?({:error, _}, Parser.split_packet(":onlycolon"))
|
|
assert match?({:error, _}, Parser.split_packet(">onlygt"))
|
|
end
|
|
end
|
|
|
|
describe "split_path/1" do
|
|
property "splits path into destination and digipeater path for any string" do
|
|
check all s <- StreamData.string(:alphanumeric, min_length: 0, max_length: 10) do
|
|
result = Parser.split_path(s)
|
|
assert match?({:ok, [_, _]}, result)
|
|
end
|
|
end
|
|
|
|
test "splits with no comma" do
|
|
assert {:ok, ["DEST", ""]} = Parser.split_path("DEST")
|
|
end
|
|
|
|
test "splits with one comma" do
|
|
assert {:ok, ["DEST", "DIGI"]} = Parser.split_path("DEST,DIGI")
|
|
end
|
|
|
|
test "returns error for more than one comma" do
|
|
assert {:ok, ["A", "A,A"]} = Parser.split_path("A,A,A")
|
|
end
|
|
end
|
|
|
|
describe "parse_callsign/1" do
|
|
property "parses valid callsigns" do
|
|
check all base <- StreamData.string(:alphanumeric, min_length: 1),
|
|
ssid <- StreamData.string(:alphanumeric, min_length: 1) do
|
|
callsign = base <> "-" <> ssid
|
|
assert {:ok, [^base, ^ssid]} = Parser.parse_callsign(callsign)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "validate_path/1" do
|
|
property "rejects paths with too many components" do
|
|
check all n <- StreamData.integer(9..20) do
|
|
path = Enum.map_join(1..n, ",", fn _ -> "WIDE1" end)
|
|
assert match?({:error, _}, Parser.validate_path(path))
|
|
end
|
|
end
|
|
|
|
property "accepts paths with 8 or fewer components" do
|
|
check all n <- StreamData.integer(1..8) do
|
|
path = Enum.map_join(1..n, ",", fn _ -> "WIDE1" end)
|
|
assert :ok = Parser.validate_path(path)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "parse_datatype/1 and parse_datatype_safe/1" do
|
|
property "parse_datatype returns an atom for any printable string" do
|
|
check all s <- StreamData.string(:printable, min_length: 1) do
|
|
assert is_atom(Parser.parse_datatype(s))
|
|
end
|
|
end
|
|
|
|
test "parse_datatype_safe returns {:ok, atom} for non-empty, {:error, _} for empty" do
|
|
assert {:ok, _} = Parser.parse_datatype_safe("!")
|
|
assert {:error, _} = Parser.parse_datatype_safe("")
|
|
end
|
|
|
|
test "returns correct atom for each known type indicator" do
|
|
assert Parser.parse_datatype(":msg") == :message
|
|
assert Parser.parse_datatype(">status") == :status
|
|
assert Parser.parse_datatype("!pos") == :position
|
|
assert Parser.parse_datatype("/tspos") == :timestamped_position
|
|
assert Parser.parse_datatype("=posmsg") == :position_with_message
|
|
assert Parser.parse_datatype("@tsmsg") == :timestamped_position_with_message
|
|
assert Parser.parse_datatype(";object") == :object
|
|
assert Parser.parse_datatype("`mic_e") == :mic_e_old
|
|
assert Parser.parse_datatype("'mic_e_old") == :mic_e_old
|
|
assert Parser.parse_datatype("_weather") == :weather
|
|
assert Parser.parse_datatype("Ttele") == :telemetry
|
|
assert Parser.parse_datatype("$raw") == :raw_gps_ultimeter
|
|
assert Parser.parse_datatype("<cap") == :station_capabilities
|
|
assert Parser.parse_datatype("?query") == :query
|
|
assert Parser.parse_datatype("{userdef") == :user_defined
|
|
assert Parser.parse_datatype("}thirdparty") == :third_party_traffic
|
|
assert Parser.parse_datatype("%item") == :item
|
|
assert Parser.parse_datatype(")item") == :item
|
|
assert Parser.parse_datatype("*peet") == :peet_logging
|
|
assert Parser.parse_datatype(",test") == :invalid_test_data
|
|
assert Parser.parse_datatype("#DFSfoo") == :df_report
|
|
assert Parser.parse_datatype("#PHGfoo") == :phg_data
|
|
assert Parser.parse_datatype("#foo") == :phg_data
|
|
assert Parser.parse_datatype("Xunknown") == :unknown_datatype
|
|
end
|
|
end
|
|
|
|
describe "parse_data/3" do
|
|
test "returns nil for unknown type" do
|
|
assert Parser.parse_data(:unknown, "", "") == nil
|
|
end
|
|
|
|
test "returns nil for invalid test data" do
|
|
assert Parser.parse_data(:invalid_test_data, "", ",testdata")[:data_type] ==
|
|
:invalid_test_data
|
|
end
|
|
|
|
test "returns map for weather" do
|
|
result = Parser.parse_data(:weather, "", "_12345678c000s000g000t000r000p000P000h00b00000")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :weather
|
|
end
|
|
|
|
test "returns map for telemetry" do
|
|
result = Parser.parse_data(:telemetry, "", "T#123,456,789,012,345,678,901,234")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :telemetry
|
|
end
|
|
|
|
test "returns map for object" do
|
|
result = Parser.parse_data(:object, "", ";OBJECT*111111z4903.50N/07201.75W>Test object")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :object
|
|
end
|
|
|
|
test "returns map for item" do
|
|
result = Parser.parse_data(:item, "", ")ITEM!4903.50N/07201.75W>Test item")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :item
|
|
end
|
|
|
|
test "returns map for status" do
|
|
result = Parser.parse_data(:status, "", ">Test status message")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :status
|
|
end
|
|
|
|
test "returns map for user_defined" do
|
|
result = Parser.parse_data(:user_defined, "", "{userdef")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :user_defined
|
|
end
|
|
|
|
# test "returns map for third_party_traffic" do
|
|
# result = Parser.parse_data(:third_party_traffic, "", "}thirdparty")
|
|
# assert is_map(result)
|
|
# assert result[:data_type] == :third_party_traffic
|
|
# end
|
|
|
|
test "returns map for peet_logging" do
|
|
result = Parser.parse_data(:peet_logging, "", "*peet")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :peet_logging
|
|
end
|
|
|
|
test "returns map for station_capabilities" do
|
|
result = Parser.parse_data(:station_capabilities, "", "<cap")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :station_capabilities
|
|
end
|
|
|
|
test "returns map for query" do
|
|
result = Parser.parse_data(:query, "", "?query")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :query
|
|
end
|
|
|
|
test "returns map for df_report" do
|
|
result = Parser.parse_data(:df_report, "", "#DFS1234rest")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :df_report
|
|
end
|
|
|
|
test "returns map for phg_data" do
|
|
result = Parser.parse_data(:phg_data, "", "#PHG1234rest")
|
|
assert is_map(result)
|
|
assert result[:data_type] == :phg_data
|
|
end
|
|
|
|
test "extracts coordinates from timestamped position with weather packet" do
|
|
# This is a typical APRS timestamped position with weather
|
|
packet = "/201739z3316.04N/09631.96W_247/002g015t090h60b10161jDvs /A=000660"
|
|
destination = "APRS"
|
|
# The data type indicator is the first character
|
|
data_type = Parser.parse_datatype(packet)
|
|
# Remove the type indicator for parse_data
|
|
data_without_type = String.slice(packet, 1..-1//1)
|
|
result = Parser.parse_data(data_type, destination, data_without_type)
|
|
assert is_map(result)
|
|
assert is_struct(result[:latitude], Decimal)
|
|
assert is_struct(result[:longitude], Decimal)
|
|
assert Decimal.equal?(Decimal.round(result[:latitude], 6), Decimal.new("33.267333"))
|
|
assert Decimal.equal?(Decimal.round(result[:longitude], 6), Decimal.new("-96.532667"))
|
|
end
|
|
|
|
test "extracts coordinates from timestamped position with weather and sets has_position" do
|
|
packet =
|
|
"KG5CK-1>APRS,TCPIP*,qAC,T2SPAIN:@201750z3301.64N/09639.10W_c038s003g004t091r000P000h62b10108"
|
|
|
|
{:ok, parsed} = Parser.parse(packet)
|
|
data = parsed.data_extended
|
|
assert is_map(data)
|
|
assert data[:data_type] == :position
|
|
end
|
|
|
|
test "extracts lat/lon from @ timestamped position with message packet (issue regression)" do
|
|
packet =
|
|
"NM6E>APOSW,TCPIP*,qAC,T2SPAIN:@201807z3311.59N/09639.67Wr/A=000656SharkRF openSPOT2 -Shack"
|
|
|
|
{:ok, parsed} = Parser.parse(packet)
|
|
data = parsed.data_extended
|
|
assert is_map(data)
|
|
assert is_struct(data[:latitude], Decimal)
|
|
assert is_struct(data[:longitude], Decimal)
|
|
refute is_nil(data[:latitude])
|
|
refute is_nil(data[:longitude])
|
|
if Map.has_key?(data, :has_location), do: assert(data[:has_location])
|
|
end
|
|
end
|
|
|
|
describe "parse/1" do
|
|
test "returns {:error, _} for obviously invalid input" do
|
|
assert match?({:error, _}, Parser.parse(""))
|
|
assert match?({:error, _}, Parser.parse("notapacket"))
|
|
end
|
|
|
|
test "extracts lat/lon from @ timestamped position with message packet (issue regression)" do
|
|
packet =
|
|
"NM6E>APOSW,TCPIP*,qAC,T2SPAIN:@201807z3311.59N/09639.67Wr/A=000656SharkRF openSPOT2 -Shack"
|
|
|
|
{:ok, parsed} = Parser.parse(packet)
|
|
data = parsed.data_extended
|
|
assert is_map(data)
|
|
assert is_struct(data[:latitude], Decimal)
|
|
assert is_struct(data[:longitude], Decimal)
|
|
refute is_nil(data[:latitude])
|
|
refute is_nil(data[:longitude])
|
|
if Map.has_key?(data, :has_location), do: assert(data[:has_location])
|
|
end
|
|
end
|
|
end
|