Fix tests

Author: gBillal

lib/turbojpeg/filter.ex

@@ -14,7 +14,7 @@ defmodule Turbojpeg.Filter do
     accepted_format: %RawVideo{pixel_format: pix_fmt} when pix_fmt in [:I420, :I422, :I444]
 
   # TODO: implement JPEG stream format
-  def_output_pad :output, accepted_format: RemoteStream
+  def_output_pad :output, flow_control: :auto, accepted_format: RemoteStream
 
   def_options quality: [
                 spec: Turbojpeg.quality(),

lib/turbojpeg/sink.ex

@@ -56,7 +56,6 @@ defmodule Turbojpeg.Sink do
 
   @impl true
   def handle_write(:input, %Buffer{payload: payload}, _ctx, state) do
-    IO.inspect(payload)
     with {:ok, data} <-
            Turbojpeg.yuv_to_jpeg(payload, state.width, state.height, state.quality, state.format),
          :ok <- File.write(state.filename, data) do

test/test_helper.exs

@@ -1 +1 @@
-ExUnit.start()
+ExUnit.start(capture_log: true)

test/turbojpeg/filter_test.exs

@@ -1,53 +1,45 @@
 defmodule Turbojpeg.FilterTest do
   use ExUnit.Case
+
+  import Membrane.ChildrenSpec
   import Membrane.Testing.Assertions
-  alias Membrane.Testing
 
-  defmodule MockSource do
-    use Membrane.Source
+  alias Membrane.Testing
 
-    def_output_pad :output, mode: :push, caps: :any
+  @stream_format %Membrane.RawVideo{
+    width: 64,
+    height: 64,
+    pixel_format: :I444,
+    framerate: nil,
+    aligned: true
+  }
 
-    def_options yuv: [spec: binary], repeat: [spec: pos_integer]
+  defp start_pipeline(jpeg, repeat) do
+    {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
+    data = List.duplicate(yuv, repeat)
 
-    @impl true
-    def handle_prepared_to_playing(_ctx, state) do
-      buffers = %Membrane.Buffer{payload: state.yuv} |> Bunch.Enum.repeated(state.repeat)
-      send(self(), :end_of_stream)
-      {{:ok, buffer: {:output, buffers}}, state}
-    end
+    structure = [
+      child(:source, %Testing.Source{output: data, stream_format: @stream_format})
+      |> child(:filter, %Turbojpeg.Filter{quality: 100})
+      |> child(:sink, Testing.Sink)
+    ]
 
-    @impl true
-    def handle_other(:end_of_stream, _ctx, state) do
-      {{:ok, end_of_stream: :output}, state}
-    end
+    Testing.Pipeline.start_link_supervised!(structure: structure)
   end
 
   test "integration test" do
-    repeat = 5
     jpeg = File.read!("fixture/ff0000_i444.jpg")
-    {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
-
-    children = [
-      source: %MockSource{yuv: yuv, repeat: repeat},
-      parser: %Membrane.Element.RawVideo.Parser{format: :I444, width: 64, height: 64},
-      filter: %Turbojpeg.Filter{quality: 100},
-      sink: Membrane.Testing.Sink
-    ]
-
-    assert {:ok, pipeline} =
-             Testing.Pipeline.start_link(%Testing.Pipeline.Options{elements: children})
+    repeat = 5
 
-    :ok = Testing.Pipeline.play(pipeline)
-    assert_pipeline_playback_changed(pipeline, _, :playing)
+    pid = start_pipeline(jpeg, repeat)
+    assert_pipeline_play(pid)
 
     1..repeat
     |> Enum.each(fn _ ->
-      assert_sink_buffer(pipeline, :sink, buffer)
+      assert_sink_buffer(pid, :sink, buffer)
       assert buffer.payload == jpeg
     end)
 
-    assert_end_of_stream(pipeline, :sink)
-    refute_sink_buffer(pipeline, :sink, _, 0)
+    assert_end_of_stream(pid, :sink)
   end
 end

test/turbojpeg_test.exs

@@ -36,7 +36,7 @@ defmodule TurbojpegTest do
              rgb(),
              format()
            ] do
-      color = :io_lib.format('#~2.16.0B~2.16.0B~2.16.0B', [r, g, b])
+      color = :io_lib.format(~c"#~2.16.0B~2.16.0B~2.16.0B", [r, g, b])
 
       jpeg =
         %Mogrify.Image{}
@@ -47,10 +47,9 @@ defmodule TurbojpegTest do
         |> Mogrify.custom("stdout", "jpg:-")
         |> Mogrify.create(buffer: true)
 
-      jpeg = Shmex.new(jpeg.buffer)
-      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
+      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg.buffer)
 
-      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg)
+      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg.buffer)
 
       {:ok, new_jpeg} = Turbojpeg.yuv_to_jpeg(yuv, width, height, 100, original_header.format)
 
@@ -77,10 +76,9 @@ defmodule TurbojpegTest do
         |> Mogrify.custom("stdout", "jpg:-")
         |> Mogrify.create(buffer: true)
 
-      jpeg = Shmex.new(jpeg.buffer)
-      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg)
+      {:ok, yuv} = Turbojpeg.jpeg_to_yuv(jpeg.buffer)
       {:ok, new_jpeg} = Turbojpeg.yuv_to_jpeg(yuv, width, height, quality, format)
-      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg)
+      {:ok, original_header} = Turbojpeg.get_jpeg_header(jpeg.buffer)
       {:ok, new_header} = Turbojpeg.get_jpeg_header(new_jpeg)
       assert original_header == new_header
     end