test: use test_messages_proto{2,3}.proto in more places

Also, generate test data for parsing tests on the fly

test/code_generation_test.exs

@@ -70,7 +70,7 @@ defmodule Protox.CodeGenerationTest do
 
     Mix.Tasks.Protox.Generate.run([
       "--output-path=#{tmp_file}",
-      "#{protox_path}/test/samples/proto3.proto"
+      "#{protox_path}/test/samples/google/test_messages_proto3.proto"
     ])
 
     assert File.exists?(tmp_file)
@@ -110,7 +110,7 @@ defmodule Protox.CodeGenerationTest do
         [
           "protox.generate",
           "--output-path=./lib/output/#{output}",
-          "#{protox_path}/test/samples/proto3.proto"
+          "#{protox_path}/test/samples/google/test_messages_proto3.proto"
         ] ++ args,
         cd: code_generation_path
       )

test/protox/parse_test.exs

@@ -2,103 +2,75 @@ defmodule Protox.ParseTest do
   use ExUnit.Case
 
   setup_all do
-    data = File.read!("./test/samples/file_descriptor_set.bin")
+    file_descriptor_set_bin_path = Protox.TmpFs.tmp_file_path!(".bin")
+    File.rm_rf!(file_descriptor_set_bin_path)
+
+    {"", 0} =
+      System.cmd("protoc", [
+        "--include_imports",
+        "-o",
+        file_descriptor_set_bin_path,
+        "./test/samples/google/test_messages_proto3.proto",
+        "./test/samples/google/test_messages_proto2.proto"
+      ])
+
+    data = File.read!(file_descriptor_set_bin_path)
+    File.rm_rf!(file_descriptor_set_bin_path)
+
     %{enums: enums, messages: messages} = Protox.Parse.parse(data)
 
     {:ok, enums: enums, messages: messages}
   end
 
   test "Parse FileDescriptorSet, protobuf 3 enums", %{enums: enums} do
-    {_, constants} = Enum.find(enums, fn {name, _} -> name == Abc.Def.MyForeignEnum end)
-    assert constants == [{0, :FOREIGN_ZERO}, {1, :FOREIGN_ONE}, {1, :FOREIGN_ONE_BIS}]
-
-    {_, constants} = Enum.find(enums, fn {name, _} -> name == Abc.Def.Proto3.NestedEnum end)
-    assert constants == [{0, :FOO}, {2, :BAR}]
-  end
+    {_, constants} =
+      Enum.find(enums, fn {name, _} -> name == ProtobufTestMessages.Proto3.ForeignEnum end)
 
-  test "Parse FileDescriptorSet, protobuf 3 messages", %{messages: messages} do
-    assert syntax(messages, Abc.Def.Proto3) == :proto3
-    fs = fields(messages, Abc.Def.Proto3)
-    assert field(fs, 1) == {:repeated, :repeated_int32, :packed, :int32}
-    assert field(fs, 2) == {:optional, :double, {:scalar, 0}, :double}
-    assert field(fs, 3) == {nil, :map_sfixed32_fixed64, :map, {:sfixed32, :fixed64}}
-    assert field(fs, 4) == {:optional, :oneof_1_int32, {:oneof, :oneof_1}, :int32}
-    assert field(fs, 5) == {:optional, :oneof_1_double, {:oneof, :oneof_1}, :double}
-
-    assert field(fs, 6) ==
-             {:optional, :oneof_1_foreign_enum, {:oneof, :oneof_1},
-              {:enum, Abc.Def.MyForeignEnum}}
-
-    assert field(fs, 7) == {:optional, :oneof_1_proto2a, {:oneof, :oneof_1}, {:message, Proto2A}}
+    assert constants == [{0, :FOREIGN_FOO}, {1, :FOREIGN_BAR}, {2, :FOREIGN_BAZ}]
 
-    assert field(fs, 8) == {nil, :map_string_proto2a, :map, {:string, {:message, Proto2A}}}
+    {_, constants} =
+      Enum.find(enums, fn {name, _} ->
+        name == ProtobufTestMessages.Proto3.TestAllTypesProto3.NestedEnum
+      end)
 
-    assert field(fs, 9) == {:optional, :bytes, {:scalar, <<>>}, :bytes}
+    assert constants == [{0, :FOO}, {1, :BAR}, {2, :BAZ}, {-1, :NEG}]
+  end
 
-    assert field(fs, 10) ==
-             {nil, :map_int64_nested_enum, :map, {:int64, {:enum, Abc.Def.Proto3.NestedEnum}}}
+  test "Parse FileDescriptorSet, protobuf 3 messages", %{messages: messages} do
+    assert syntax(messages, ProtobufTestMessages.Proto3.TestAllTypesProto3) == :proto3
 
-    assert field(fs, 134) == {:optional, :oneof_2_int32, {:oneof, :oneof_2}, :int32}
+    fs = fields(messages, ProtobufTestMessages.Proto3.TestAllTypesProto3)
 
-    assert field(fs, 135) ==
-             {:optional, :oneof_2_nested_enum, {:oneof, :oneof_2},
-              {:enum, Abc.Def.Proto3.NestedEnum}}
+    assert field(fs, 12) == {:optional, :optional_double, {:scalar, 0}, :double}
+    assert field(fs, 31) == {:repeated, :repeated_int32, :packed, :int32}
+    assert field(fs, 32) == {:repeated, :repeated_int64, :packed, :int64}
+    assert field(fs, 64) == {nil, :map_sfixed32_sfixed32, :map, {:sfixed32, :sfixed32}}
+    assert field(fs, 75) == {:repeated, :packed_int32, :packed, :int32}
+    assert field(fs, 89) == {:repeated, :unpacked_int32, :unpacked, :int32}
+    assert field(fs, 111) == {:optional, :oneof_uint32, {:oneof, :oneof_field}, :uint32}
 
-    assert field(fs, 9999) ==
-             {:optional, :nested_enum, {:scalar, :FOO}, {:enum, Abc.Def.Proto3.NestedEnum}}
+    assert field(fs, 119) ==
+             {:optional, :oneof_enum, {:oneof, :oneof_field},
+              {:enum, ProtobufTestMessages.Proto3.TestAllTypesProto3.NestedEnum}}
 
-    assert syntax(messages, Abc.Def.EmptyProto3) == :proto3
-    assert [] = fields(messages, Abc.Def.EmptyProto3)
+    assert [] = fields(messages, ProtobufTestMessages.Proto3.NullHypothesisProto3)
   end
 
   test "Parse FileDescriptorSet, protobuf 2 enums", %{enums: enums} do
-    {_, constants} = Enum.find(enums, fn {name, _} -> name == Proto2A.NestedEnum end)
-    assert constants == [{0, :N_ZERO}, {3, :N_THREE}]
+    {_, constants} =
+      Enum.find(enums, fn {name, _} -> name == ProtobufTestMessages.Proto2.ForeignEnumProto2 end)
+
+    assert constants == [{0, :FOREIGN_FOO}, {1, :FOREIGN_BAR}, {2, :FOREIGN_BAZ}]
   end
 
   test "Parse FileDescriptorSet, protobuf 2 messages", %{messages: messages} do
-    assert syntax(messages, Proto2A.NestedMessage) == :proto2
-    fs = fields(messages, Proto2A.NestedMessage)
-    assert field(fs, 1) == {:required, :required_string, {:scalar, "foo"}, :string}
-    assert field(fs, 2) == {:optional, :optional_float, {:scalar, -1.1}, :float}
-    assert field(fs, 3) == {:optional, :optional_fixed64, {:scalar, 32_108}, :fixed64}
-
-    assert syntax(messages, Proto2A) == :proto2
-    fs = fields(messages, Proto2A)
-    assert field(fs, 1) == {:repeated, :repeated_int32_packed, :packed, :int32}
-    assert field(fs, 2) == {:repeated, :repeated_int32_unpacked, :unpacked, :int32}
-
-    assert field(fs, 3) ==
-             {:optional, :optional_nested_message, {:scalar, nil},
-              {:message, Proto2A.NestedMessage}}
-
-    assert field(fs, 4) ==
-             {:repeated, :repeated_nested_enum, :unpacked, {:enum, Proto2A.NestedEnum}}
-
-    assert field(fs, 5) ==
-             {:repeated, :repeated_nested_message, :unpacked, {:message, Proto2A.NestedMessage}}
-
-    assert field(fs, 6) == {:optional, :bytes, {:scalar, <<96, 118>>}, :bytes}
-    assert field(fs, 126) == {:optional, :extension_int32, {:scalar, 0}, :int32}
-    assert field(fs, 199) == {:optional, :extension_double, {:scalar, 42.42}, :double}
-
-    assert syntax(messages, Proto2B) == :proto2
-    fs = fields(messages, Proto2B)
-
-    assert field(fs, 1) ==
-             {:optional, :optional_proto2a_nested_enum, {:scalar, :N_ZERO},
-              {:enum, Proto2A.NestedEnum}}
-
-    assert field(fs, 2) ==
-             {:required, :required_proto2a_nested_enum, {:scalar, :N_THREE},
-              {:enum, Proto2A.NestedEnum}}
-  end
+    assert syntax(messages, ProtobufTestMessages.Proto2.TestAllRequiredTypesProto2) == :proto2
 
-  test "Parse Proto3, packed and unpacked fields", %{messages: messages} do
-    fs = fields(messages, Abc.Def.Proto3)
+    fs = fields(messages, ProtobufTestMessages.Proto2.TestAllRequiredTypesProto2)
 
-    assert field(fs, 200) == {:repeated, :repeated_int32_packed, :packed, :int32}
-    assert field(fs, 201) == {:repeated, :repeated_int32_unpacked, :unpacked, :int32}
+    assert field(fs, 1) == {:required, :required_int32, {:scalar, 0}, :int32}
+    assert field(fs, 11) == {:required, :required_float, {:scalar, 0.0}, :float}
+    assert field(fs, 15) == {:required, :required_bytes, {:scalar, <<>>}, :bytes}
   end
 
   defp field(fields, tag) do

test/support/messages.ex

@@ -10,10 +10,7 @@ defmodule Protox.Messages do
       "./test/samples/java_foo.proto",
       "./test/samples/messages.proto",
       "./test/samples/no_uf_name_clash.proto",
-      "./test/samples/optional.proto",
-      "./test/samples/proto2.proto",
-      "./test/samples/proto2_extension.proto",
-      "./test/samples/proto3.proto"
+      "./test/samples/optional.proto"
     ]
 
   # To test the :keep_unknown_fields option.