Write and fix tests

Author: FelonEkonom

lib/membrane_http_adaptive_stream/hls_source.ex

@@ -64,7 +64,7 @@ defmodule Membrane.HLS.Source do
               ],
               buffered_stream_time: [
                 spec: Membrane.Time.t(),
-                default: Membrane.Time.seconds(1),
+                default: Membrane.Time.seconds(10),
                 inspector: &Membrane.Time.inspect/1,
                 description: """
                 Amount of time of stream, that will be buffered by #{inspect(__MODULE__)}.
@@ -122,7 +122,7 @@ defmodule Membrane.HLS.Source do
     {[audio_stream_format], [video_stream_format]} =
       ClientGenServer.get_tracks_info(state.client_genserver)
       |> Map.values()
-      |> Enum.split_with(&is_audio_stream_format/1)
+      |> Enum.split_with(&audio_stream_format?/1)
 
     actions = [
       stream_format: {:audio_output, audio_stream_format},
@@ -133,7 +133,7 @@ defmodule Membrane.HLS.Source do
     {actions, state}
   end
 
-  defp is_audio_stream_format(stream_format) do
+  defp audio_stream_format?(stream_format) do
     case stream_format do
       %RemoteStream{content_format: AAC} -> true
       %RemoteStream{content_format: H264} -> false

lib/membrane_http_adaptive_stream/hls_source/client_genserver.ex

@@ -56,39 +56,7 @@ defmodule Membrane.HLS.Source.ClientGenServer do
   def handle_info(:setup, state) do
     state =
       %{state | client: Client.new(state.url)}
-
-    # |> choose_variant()
-
-    variants = Client.get_variants(state.client)
-
-    state =
-      if variants != %{} do
-        get_resolution_fn = fn {_id, %{resolution: {width, height}}} -> width * height end
-        get_bandwidth_fn = fn {_id, %{bandwidth: bandwidth}} -> bandwidth end
-
-        chosen_variant_id =
-          case state.variant_selection_policy do
-            :lowest_resolution ->
-              variants |> Enum.min_by(get_resolution_fn) |> elem(0)
-
-            :highest_resolution ->
-              variants |> Enum.max_by(get_resolution_fn) |> elem(0)
-
-            :lowest_bandwidth ->
-              variants |> Enum.min_by(get_bandwidth_fn) |> elem(0)
-
-            :highest_bandwidth ->
-              variants |> Enum.max_by(get_bandwidth_fn) |> elem(0)
-
-            custom_policy when is_function(custom_policy, 1) ->
-              variants |> custom_policy.()
-          end
-
-        client = state.client |> Client.choose_variant(chosen_variant_id)
-        %{state | client: client}
-      else
-        state
-      end
+      |> choose_variant()
 
     {:noreply, state}
   end

test/membrane_http_adaptive_stream/integration_test/fixtures/hls_source/fmp4/audio.aac

@@ -2,57 +2,102 @@ defmodule Membrane.HLS.Source.Test do
   use ExUnit.Case, async: true
 
   import Membrane.ChildrenSpec
-  import Membrane.Testing.Assertions
-
   alias Membrane.Testing
 
   @mpegts_url "https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8"
   @fmp4_url "https://raw.githubusercontent.com/membraneframework-labs/ex_hls/refs/heads/plug-demuxing-engine-into-client/fixture/output.m3u8"
 
-  @tag :a
-  test "fmp4" do
-    spec = [
-      child(:hls_source, %Membrane.HLS.Source{url: @fmp4_url})
-      |> via_out(:video_output)
-      |> child(%Membrane.Transcoder{output_stream_format: Membrane.RawVideo})
-      |> child(Membrane.SDL.Player),
-      get_child(:hls_source)
-      |> via_out(:audio_output)
-      |> child(%Membrane.Transcoder{output_stream_format: Membrane.RawAudio})
-      |> child(Membrane.PortAudio.Sink)
-    ]
+  @hls_source_fixtures "test/membrane_http_adaptive_stream/integration_test/fixtures/hls_source"
+  @fmp4_video_fixture Path.join(@hls_source_fixtures, "fmp4/video.h264")
+  @fmp4_audio_fixture Path.join(@hls_source_fixtures, "fmp4/audio.aac")
+  @mpeg_ts_video_fixture Path.join(@hls_source_fixtures, "mpeg_ts/video.h264")
+  @mpeg_ts_audio_fixture Path.join(@hls_source_fixtures, "mpeg_ts/audio.aac")
+
+  describe "Membrane.HLS.Source demuxes audio and video from HLS stream" do
+    @tag :tmp_dir
+    test "(fMP4)", %{tmp_dir: tmp_dir} do
+      audio_result_file = Path.join(tmp_dir, "audio.aac")
+      video_result_file = Path.join(tmp_dir, "video.h264")
+
+      spec =
+        pipeline_spec(
+          @fmp4_url,
+          %Membrane.Transcoder{output_stream_format: Membrane.AAC},
+          audio_result_file,
+          video_result_file
+        )
+
+      pipeline = Testing.Pipeline.start_link_supervised!(spec: spec)
+      Process.sleep(10_000)
+      Testing.Pipeline.terminate(pipeline)
 
-    pipeline = Testing.Pipeline.start_link_supervised!(spec: spec)
+      # fixtures created locally with a quite good internet connection have
+      #  - 139_085 bytes for audio
+      #  - 500_571 bytes for video
+      assert_track(audio_result_file, @fmp4_audio_fixture, 70_000)
+      assert_track(video_result_file, @fmp4_video_fixture, 200_000)
+    end
 
-    Process.sleep(10_000)
-    Testing.Pipeline.terminate(pipeline)
+    @tag :tmp_dir
+    test "(MPEG-TS)", %{tmp_dir: tmp_dir} do
+      audio_result_file = Path.join(tmp_dir, "audio.aac")
+      video_result_file = Path.join(tmp_dir, "video.h264")
+
+      spec =
+        pipeline_spec(
+          @mpegts_url,
+          %Membrane.Transcoder{
+            assumed_input_stream_format: %Membrane.AAC{
+              encapsulation: :ADTS
+            },
+            output_stream_format: Membrane.AAC
+          },
+          audio_result_file,
+          video_result_file
+        )
+
+      pipeline = Testing.Pipeline.start_link_supervised!(spec: spec)
+      Process.sleep(10_000)
+      Testing.Pipeline.terminate(pipeline)
+
+      # fixtures created locally with a quite good internet connection have
+      #  - 78_732 bytes for audio
+      #  - 136_754 bytes for video
+      assert_track(audio_result_file, @mpeg_ts_audio_fixture, 40_000)
+      assert_track(video_result_file, @mpeg_ts_video_fixture, 70_000)
+    end
   end
 
-  @tag :b
-  test "mpeg-ts" do
-    spec = [
-      child(:hls_source, %Membrane.HLS.Source{url: @mpegts_url})
+  defp pipeline_spec(url, audio_transcoder, audio_result_file, video_result_file) do
+    [
+      child(:hls_source, %Membrane.HLS.Source{
+        url: url,
+        variant_selection_policy: :lowest_resolution
+      })
       |> via_out(:video_output)
       |> child(%Membrane.Transcoder{
-        output_stream_format: Membrane.RawVideo
+        output_stream_format: Membrane.H264
       })
       |> child(Membrane.Realtimer)
-      |> child(Membrane.SDL.Player),
+      |> child(%Membrane.File.Sink{
+        location: video_result_file
+      }),
       get_child(:hls_source)
       |> via_out(:audio_output)
-      |> child(%Membrane.Transcoder{
-        assumed_input_stream_format: %Membrane.AAC{
-          encapsulation: :ADTS
-        },
-        output_stream_format: Membrane.RawAudio
-      })
+      |> child(audio_transcoder)
       |> child(Membrane.Realtimer)
-      |> child(Membrane.PortAudio.Sink)
+      |> child(%Membrane.File.Sink{
+        location: audio_result_file
+      })
     ]
+  end
 
-    pipeline = Testing.Pipeline.start_link_supervised!(spec: spec)
+  defp assert_track(result_file, fixture, asserted_bytes) do
+    <<expected_prefix::binary-size(asserted_bytes), _sufix::binary>> =
+      fixture |> File.read!()
 
-    Process.sleep(10_000)
-    Testing.Pipeline.terminate(pipeline)
+    assert result_file
+           |> File.read!()
+           |> String.starts_with?(expected_prefix)
   end
 end