diff --git a/test/buffer_test.exs b/test/buffer_test.exs new file mode 100644 index 0000000..ca0459d --- /dev/null +++ b/test/buffer_test.exs @@ -0,0 +1,42 @@ +defmodule BufferTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :buffer + test "buffer" do + testproc = self() + + start = 1 + tend = 100 + size = 3 + + # Create a range. + Obs.range(start, tend, 100) + |> Obs.buffer(size) + |> Obs.each(fn v -> + Logger.debug("Sending #{inspect(v)}") + send(testproc, v) + end) + + # Receive all the values. + Enum.chunk_every(1..100, size) + |> Enum.map(fn list -> + Logger.debug("Waiting for #{inspect(list)}") + + receive do + ^list -> Logger.debug("Got list #{inspect(list)}") + end + end) + + # Receive no other values. + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value:" == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/chunk_test.exs b/test/chunk_test.exs new file mode 100644 index 0000000..3eee39e --- /dev/null +++ b/test/chunk_test.exs @@ -0,0 +1,46 @@ +defmodule ChunkTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :chunk + test "chunk" do + testproc = self() + + start = 1 + tend = 50 + size = 5 + + # Create a range. + Obs.range(start, tend, 100) + # We should consume 5 values each time. + |> Obs.chunk(size * 100 + 10) + |> Obs.each(fn v -> + Logger.debug("Sending #{inspect(v, charlists: :as_lists)}") + send(testproc, v) + end) + + # Receive all the values. + Enum.chunk_every(1..50, size) + |> Enum.map(fn list -> + Logger.debug("Waiting for #{inspect(list, charlists: :as_lists)}") + + receive do + ^list -> Logger.debug("Got list #{inspect(list, charlists: :as_lists)}") + after + 10000 -> + assert "Did not receive list in time: #{inspect(list, charlists: :as_lists)}" == "" + end + end) + + # Receive no other values. + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/combineLatestSilent_test.exs b/test/combineLatestSilent_test.exs new file mode 100644 index 0000000..ae371d7 --- /dev/null +++ b/test/combineLatestSilent_test.exs @@ -0,0 +1,83 @@ +defmodule CombineLatestSilentTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :combinelatestsilent + test "Combine Latest Silent" do + # 1 2 3 + # 11 12 13 14 15 + # =================================== + # 1/11 2/11 3/12 + + testproc = self() + + {:ok, pid1} = GenObservable.spawn_supervised(Observables.Subject) + xs = Obs.from_pid(pid1) + + {:ok, pid2} = GenObservable.spawn_supervised(Observables.Subject) + ys = Obs.from_pid(pid2) + + Obs.combinelatestsilent(xs, ys, left: nil, right: nil, silent: :right) + |> Obs.inspect() + |> Obs.map(fn v -> send(testproc, v) end) + + # Send first value, should not produce. + GenObservable.send_event(pid1, :x0) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + + # Send second value, should not produce because silent. + GenObservable.send_event(pid2, :y0) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + + # Update the left observable. Should produce with history. + GenObservable.send_event(pid1, :x1) + assert_receive({:x1, :y0}, 5000, "did not get this message {:x1, :y0}!") + + # Update the right observable, should be silent. + GenObservable.send_event(pid2, :y1) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + + GenObservable.send_event(pid2, :y2) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + + GenObservable.send_event(pid2, :y3) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + + # Send a final value, should produce. + GenObservable.send_event(pid1, :x2) + assert_receive({:x2, :y3}, 1000, "did not get this message {:x2, :y3}!") + + # Mailbox should be empty. + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 100 -> :ok + end + end +end diff --git a/test/combineLatest_test.exs b/test/combineLatest_test.exs new file mode 100644 index 0000000..7c83794 --- /dev/null +++ b/test/combineLatest_test.exs @@ -0,0 +1,50 @@ +defmodule CombineLatestTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :combinelatest + test "Combine Latest" do + testproc = self() + + {:ok, pid1} = GenObservable.spawn_supervised(Observables.Subject) + xs = Obs.from_pid(pid1) + + {:ok, pid2} = GenObservable.spawn_supervised(Observables.Subject) + ys = Obs.from_pid(pid2) + + Obs.combinelatest(xs, ys, left: nil, right: nil) + |> Obs.inspect() + |> Obs.map(fn v -> send(testproc, v) end) + + # Send first value, should not produce. + GenObservable.send_event(pid1, :x0) + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 0 -> :ok + end + + # Send second value, should produce. + GenObservable.send_event(pid2, :y0) + assert_receive({:x0, :y0}, 1000, "did not get this message!") + + # Update the left observable. Shoudl produce with history. + GenObservable.send_event(pid1, :x1) + assert_receive({:x1, :y0}, 1000, "did not get this message!") + + GenObservable.send_event(pid2, :y1) + assert_receive({:x1, :y1}, 1000, "did not get this message!") + + # Send a final value, should produce. + GenObservable.send_event(pid1, :xfinal) + assert_receive({:xfinal, :y1}, 1000, "did not get this message!") + + receive do + x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") + after + 0 -> :ok + end + end +end diff --git a/test/distinct_test.exs b/test/distinct_test.exs new file mode 100644 index 0000000..8bf5a69 --- /dev/null +++ b/test/distinct_test.exs @@ -0,0 +1,32 @@ +defmodule DistinctTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :distinct + test "Distinct" do + testproc = self() + + xs = [1, 1, 1, 1] + + xs + |> Obs.from_enum(100) + |> Obs.distinct() + |> Obs.map(fn v -> send(testproc, v) end) + + Enum.uniq(xs) + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + + receive do + ^x -> assert "duplicates" == "" + after + 1000 -> :ok + end + end) + + assert 5 == 5 + end +end diff --git a/test/each_test.exs b/test/each_test.exs new file mode 100644 index 0000000..678cdc3 --- /dev/null +++ b/test/each_test.exs @@ -0,0 +1,35 @@ +defmodule EachTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :each + test "Each" do + testproc = self() + + xs = [1, 1, 1, 1] + + xs + |> Obs.from_enum(100) + |> Obs.each(fn x -> IO.inspect(x) end) + |> Obs.map(fn v -> send(testproc, v) end) + + xs + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + receive do + x -> + Logger.error("Received another value, did not want") + assert 5 == 10 + after + 1000 -> + :ok + end + + assert 5 == 5 + end +end diff --git a/test/filter_test.exs b/test/filter_test.exs new file mode 100644 index 0000000..319f54b --- /dev/null +++ b/test/filter_test.exs @@ -0,0 +1,33 @@ +defmodule FilterTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + @tag :filter + test "Filter" do + testproc = self() + + xs = [1, 2, 3, 1, 2, 3, 3, 2, 1] + + xs + |> Obs.from_enum(100) + |> Obs.filter(fn x -> x > 2 end) + |> Obs.map(fn v -> send(testproc, v) end) + + xs + |> Enum.filter(fn x -> x > 2 end) + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x)}" == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/from_enum_test.exs b/test/from_enum_test.exs new file mode 100644 index 0000000..979f788 --- /dev/null +++ b/test/from_enum_test.exs @@ -0,0 +1,25 @@ +defmodule FromEnumTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :fromenum + test "Test from enum" do + testproc = self() + + xs = [1, 2, 3] + + xs + |> Obs.from_enum(1000) + |> Obs.map(fn v -> send(testproc, v) end) + + xs + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + assert 5 == 5 + end +end diff --git a/test/map_test.exs b/test/map_test.exs new file mode 100644 index 0000000..465b849 --- /dev/null +++ b/test/map_test.exs @@ -0,0 +1,26 @@ +defmodule MapTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :map + test "Map" do + testproc = self() + + xs = [1, 1, 1, 1] + + xs + |> Obs.from_enum(100) + |> Obs.map(fn x -> x + 100 end) + |> Obs.map(fn v -> send(testproc, v) end) + + Enum.map(xs, fn x -> x + 100 end) + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + assert 5 == 5 + end +end diff --git a/test/merge_test.exs b/test/merge_test.exs new file mode 100644 index 0000000..7423e2f --- /dev/null +++ b/test/merge_test.exs @@ -0,0 +1,30 @@ +defmodule MergeTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :merge + test "Merge" do + Code.load_file("test/util.ex") + + testproc = self() + + xs = [1, 2, 3] + ys = [4, 5, 6] + + ys + |> Obs.from_enum(100) + |> Obs.merge(Obs.from_enum(xs, 100)) + |> Obs.map(fn v -> send(testproc, v) end) + + (xs ++ ys) + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + Test.Util.sleep(3000) + assert 5 == 5 + end +end diff --git a/test/observables_test.exs b/test/observables_test.exs index fe4e63d..37e872d 100644 --- a/test/observables_test.exs +++ b/test/observables_test.exs @@ -3,14 +3,6 @@ defmodule ObservablesTest do alias Observables.{Obs, GenObservable} require Logger - def sleep(ms) do - receive do - :nevergonnahappen -> :ok - after - ms -> :ok - end - end - @tag :frompid test "Test from pid" do testproc = self() @@ -32,565 +24,4 @@ defmodule ObservablesTest do assert 5 == 5 end - - @tag :fromenum - test "Test from enum" do - testproc = self() - - xs = [1, 2, 3] - - xs - |> Obs.from_enum(1000) - |> Obs.map(fn v -> send(testproc, v) end) - - xs - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - assert 5 == 5 - end - - @tag :merge - test "Merge" do - testproc = self() - - xs = [1, 2, 3] - ys = [4, 5, 6] - - ys - |> Obs.from_enum(100) - |> Obs.merge(Obs.from_enum(xs, 100)) - |> Obs.map(fn v -> send(testproc, v) end) - - (xs ++ ys) - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - sleep(3000) - assert 5 == 5 - end - - @tag :map - test "Map" do - testproc = self() - - xs = [1, 1, 1, 1] - - xs - |> Obs.from_enum(100) - |> Obs.map(fn x -> x + 100 end) - |> Obs.map(fn v -> send(testproc, v) end) - - Enum.map(xs, fn x -> x + 100 end) - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - assert 5 == 5 - end - - @tag :distinct - test "Distinct" do - testproc = self() - - xs = [1, 1, 1, 1] - - xs - |> Obs.from_enum(100) - |> Obs.distinct() - |> Obs.map(fn v -> send(testproc, v) end) - - Enum.uniq(xs) - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - - receive do - ^x -> assert "duplicates" == "" - after - 1000 -> :ok - end - end) - - assert 5 == 5 - end - - @tag :each - test "Each" do - testproc = self() - - xs = [1, 1, 1, 1] - - xs - |> Obs.from_enum(100) - |> Obs.each(fn x -> IO.inspect(x) end) - |> Obs.map(fn v -> send(testproc, v) end) - - xs - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - receive do - x -> - Logger.error("Received another value, did not want") - assert 5 == 10 - after - 1000 -> - :ok - end - - assert 5 == 5 - end - - @tag :filter - test "Filter" do - testproc = self() - - xs = [1, 2, 3, 1, 2, 3, 3, 2, 1] - - xs - |> Obs.from_enum(100) - |> Obs.filter(fn x -> x > 2 end) - |> Obs.map(fn v -> send(testproc, v) end) - - xs - |> Enum.filter(fn x -> x > 2 end) - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x)}" == "" - after - 1000 -> - :ok - end - end - - @tag :startswith - test "Starts with" do - testproc = self() - - first = [0] - xs = [1, 2, 3] - - xs - |> Obs.from_enum(100) - |> Obs.starts_with(first) - |> Obs.map(fn v -> send(testproc, v) end) - - (xs ++ first) - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x)}" == "" - after - 1000 -> - :ok - end - end - - @tag :switch - test "switch" do - testproc = self() - - {:ok, pid} = GenObservable.spawn_supervised(Observables.Subject, 0) - - Obs.from_pid(pid) - |> Obs.switch() - |> Obs.map(fn v -> send(testproc, v) end) - - x = - 1..5 - |> Enum.to_list() - |> Obs.from_enum() - - Logger.debug("Setting new observable x") - GenObservable.send_event(pid, x) - sleep(10000) - - y = - 6..10 - |> Enum.to_list() - |> Obs.from_enum() - - Logger.debug("Setting new observable y") - GenObservable.send_event(pid, y) - - 1..10 - |> Enum.map(fn x -> - receive do - v -> Logger.debug("Got #{v}") - end - end) - - assert 5 == 5 - end - - @tag :range - test "range" do - testproc = self() - - Obs.range(1, 5, 500) - |> Obs.map(fn x -> send(testproc, x) end) - - 1..5 - |> Enum.map(fn x -> - receive do - v -> Logger.debug("Got #{v}") - end - end) - - assert 5 == 5 - end - - @tag :zip - test "zip" do - testproc = self() - - Obs.range(1, 5, 500) - |> Obs.zip(Obs.range(1, 5, 500)) - |> Obs.map(fn x -> send(testproc, x) end) - - 1..5 - |> Enum.map(fn x -> - receive do - {^x, ^x} -> Logger.debug("Got #{inspect({x, x})}") - end - end) - - sleep(5000) - end - - @tag :zip - test "zip uneven inputs" do - testproc = self() - - Obs.range(1, 5, 500) - |> Obs.zip(Obs.range(1, 10, 500)) - |> Obs.map(fn x -> send(testproc, x) end) - - 1..5 - |> Enum.map(fn x -> - receive do - {^x, ^x} -> Logger.debug("Got #{inspect({x, x})}") - end - end) - - sleep(5000) - end - - @tag :repeat - test "repeat" do - testproc = self() - - Obs.repeat( - fn -> - send(testproc, :hello) - end, - interval: 500, - times: 5 - ) - - [:hello, :hello, :hello, :hello, :hello] - |> Enum.map(fn x -> - receive do - ^x -> Logger.debug("Got #{x}") - end - end) - - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x)}" == "" - after - 1000 -> - :ok - end - - assert 5 == 5 - end - - @tag :buffer - test "buffer" do - testproc = self() - - start = 1 - tend = 100 - size = 3 - - # Create a range. - Obs.range(start, tend, 100) - |> Obs.buffer(size) - |> Obs.each(fn v -> - Logger.debug("Sending #{inspect(v)}") - send(testproc, v) - end) - - # Receive all the values. - Enum.chunk_every(1..100, size) - |> Enum.map(fn list -> - Logger.debug("Waiting for #{inspect(list)}") - - receive do - ^list -> Logger.debug("Got list #{inspect(list)}") - end - end) - - # Receive no other values. - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value:" == "" - after - 1000 -> - :ok - end - end - - @tag :chunk - test "chunk" do - testproc = self() - - start = 1 - tend = 50 - size = 5 - - # Create a range. - Obs.range(start, tend, 100) - # We should consume 5 values each time. - |> Obs.chunk(size * 100 + 10) - |> Obs.each(fn v -> - Logger.debug("Sending #{inspect(v, charlists: :as_lists)}") - send(testproc, v) - end) - - # Receive all the values. - Enum.chunk_every(1..50, size) - |> Enum.map(fn list -> - Logger.debug("Waiting for #{inspect(list, charlists: :as_lists)}") - - receive do - ^list -> Logger.debug("Got list #{inspect(list, charlists: :as_lists)}") - after - 10000 -> - assert "Did not receive list in time: #{inspect(list, charlists: :as_lists)}" == "" - end - end) - - # Receive no other values. - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" - after - 1000 -> - :ok - end - end - - @tag :scan - test "scan" do - testproc = self() - - start = 1 - tend = 50 - - # Create a range. - Obs.range(start, tend, 100) - |> Obs.scan(fn x, y -> x + y end) - |> Obs.each(fn v -> - Logger.debug("Sending #{inspect(v, charlists: :as_lists)}") - send(testproc, v) - end) - - # Receive all the values. - Enum.scan(1..50, fn x, y -> x + y end) - |> Enum.map(fn v -> - receive do - ^v -> :ok - after - 10000 -> - assert "Did not receive item in time: #{inspect(v)}" == "" - end - end) - - # Receive no other values. - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" - after - 1000 -> - :ok - end - end - - @tag :take - test "Take" do - testproc = self() - - xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] - - xs - |> Obs.from_enum(100) - |> Obs.take(4) - |> Obs.map(fn v -> send(testproc, v) end) - - [1, 2, 3, 4] - |> Enum.map(fn x -> - receive do - ^x -> :ok - end - end) - - # Receive no other values. - receive do - x -> - Logger.error("Received another value, did not want") - assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" - after - 1000 -> - :ok - end - end - - @tag :combinelatest - test "Combine Latest" do - testproc = self() - - {:ok, pid1} = GenObservable.spawn_supervised(Observables.Subject) - xs = Obs.from_pid(pid1) - - {:ok, pid2} = GenObservable.spawn_supervised(Observables.Subject) - ys = Obs.from_pid(pid2) - - Obs.combinelatest(xs, ys, left: nil, right: nil) - |> Obs.inspect() - |> Obs.map(fn v -> send(testproc, v) end) - - # Send first value, should not produce. - GenObservable.send_event(pid1, :x0) - - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 0 -> :ok - end - - # Send second value, should produce. - GenObservable.send_event(pid2, :y0) - assert_receive({:x0, :y0}, 1000, "did not get this message!") - - # Update the left observable. Shoudl produce with history. - GenObservable.send_event(pid1, :x1) - assert_receive({:x1, :y0}, 1000, "did not get this message!") - - GenObservable.send_event(pid2, :y1) - assert_receive({:x1, :y1}, 1000, "did not get this message!") - - # Send a final value, should produce. - GenObservable.send_event(pid1, :xfinal) - assert_receive({:xfinal, :y1}, 1000, "did not get this message!") - - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 0 -> :ok - end - end - - @tag :combinelatestsilent - test "Combine Latest Silent" do - # 1 2 3 - # 11 12 13 14 15 - # =================================== - # 1/11 2/11 3/12 - - testproc = self() - - {:ok, pid1} = GenObservable.spawn_supervised(Observables.Subject) - xs = Obs.from_pid(pid1) - - {:ok, pid2} = GenObservable.spawn_supervised(Observables.Subject) - ys = Obs.from_pid(pid2) - - Obs.combinelatestsilent(xs, ys, [left: nil, right: nil, silent: :right]) - |> Obs.inspect() - |> Obs.map(fn v -> send(testproc, v) end) - - # Send first value, should not produce. - GenObservable.send_event(pid1, :x0) - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - - # Send second value, should not produce because silent. - GenObservable.send_event(pid2, :y0) - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - - # Update the left observable. Should produce with history. - GenObservable.send_event(pid1, :x1) - assert_receive({:x1, :y0}, 5000, "did not get this message {:x1, :y0}!") - - # Update the right observable, should be silent. - GenObservable.send_event(pid2, :y1) - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - - GenObservable.send_event(pid2, :y2) - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - - GenObservable.send_event(pid2, :y3) - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - # Send a final value, should produce. - GenObservable.send_event(pid1, :x2) - assert_receive({:x2, :y3}, 1000, "did not get this message {:x2, :y3}!") - - # Mailbox should be empty. - receive do - x -> flunk("Mailbox was supposed to be empty, got: #{inspect(x)}") - after - 100 -> :ok - end - end end diff --git a/test/range_test.exs b/test/range_test.exs new file mode 100644 index 0000000..8b5696e --- /dev/null +++ b/test/range_test.exs @@ -0,0 +1,22 @@ +defmodule RangeTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :range + test "range" do + testproc = self() + + Obs.range(1, 5, 500) + |> Obs.map(fn x -> send(testproc, x) end) + + 1..5 + |> Enum.map(fn x -> + receive do + v -> Logger.debug("Got #{v}") + end + end) + + assert 5 == 5 + end +end diff --git a/test/repeat_test.exs b/test/repeat_test.exs new file mode 100644 index 0000000..41532ca --- /dev/null +++ b/test/repeat_test.exs @@ -0,0 +1,36 @@ +defmodule RepeatTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :repeat + test "repeat" do + testproc = self() + + Obs.repeat( + fn -> + send(testproc, :hello) + end, + interval: 500, + times: 5 + ) + + [:hello, :hello, :hello, :hello, :hello] + |> Enum.map(fn x -> + receive do + ^x -> Logger.debug("Got #{x}") + end + end) + + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x)}" == "" + after + 1000 -> + :ok + end + + assert 5 == 5 + end +end diff --git a/test/scan_test.exs b/test/scan_test.exs new file mode 100644 index 0000000..dc416cd --- /dev/null +++ b/test/scan_test.exs @@ -0,0 +1,42 @@ +defmodule ScanTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :scan + test "scan" do + testproc = self() + + start = 1 + tend = 50 + + # Create a range. + Obs.range(start, tend, 100) + |> Obs.scan(fn x, y -> x + y end) + |> Obs.each(fn v -> + Logger.debug("Sending #{inspect(v, charlists: :as_lists)}") + send(testproc, v) + end) + + # Receive all the values. + Enum.scan(1..50, fn x, y -> x + y end) + |> Enum.map(fn v -> + receive do + ^v -> :ok + after + 10000 -> + assert "Did not receive item in time: #{inspect(v)}" == "" + end + end) + + # Receive no other values. + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/starts_with_test.exs b/test/starts_with_test.exs new file mode 100644 index 0000000..6f5d1c1 --- /dev/null +++ b/test/starts_with_test.exs @@ -0,0 +1,34 @@ +defmodule StartsWithTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :startswith + test "Starts with" do + testproc = self() + + first = [0] + xs = [1, 2, 3] + + xs + |> Obs.from_enum(100) + |> Obs.starts_with(first) + |> Obs.map(fn v -> send(testproc, v) end) + + (xs ++ first) + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x)}" == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/subject_test.exs b/test/subject_test.exs new file mode 100644 index 0000000..b8d01b5 --- /dev/null +++ b/test/subject_test.exs @@ -0,0 +1,2 @@ +defmodule SubjectTest do +end diff --git a/test/switch_test.exs b/test/switch_test.exs new file mode 100644 index 0000000..9c44709 --- /dev/null +++ b/test/switch_test.exs @@ -0,0 +1,43 @@ +defmodule SwitchTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :switch + test "switch" do + Code.load_file("test/util.ex") + testproc = self() + + {:ok, pid} = GenObservable.spawn_supervised(Observables.Subject, 0) + + Obs.from_pid(pid) + |> Obs.switch() + |> Obs.map(fn v -> send(testproc, v) end) + + x = + 1..5 + |> Enum.to_list() + |> Obs.from_enum() + + Logger.debug("Setting new observable x") + GenObservable.send_event(pid, x) + Test.Util.sleep(10000) + + y = + 6..10 + |> Enum.to_list() + |> Obs.from_enum() + + Logger.debug("Setting new observable y") + GenObservable.send_event(pid, y) + + 1..10 + |> Enum.map(fn x -> + receive do + v -> Logger.debug("Got #{v}") + end + end) + + assert 5 == 5 + end +end diff --git a/test/take_test.exs b/test/take_test.exs new file mode 100644 index 0000000..aa9eac4 --- /dev/null +++ b/test/take_test.exs @@ -0,0 +1,33 @@ +defmodule TakeTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + @tag :take + test "Take" do + testproc = self() + + xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] + + xs + |> Obs.from_enum(100) + |> Obs.take(4) + |> Obs.map(fn v -> send(testproc, v) end) + + [1, 2, 3, 4] + |> Enum.map(fn x -> + receive do + ^x -> :ok + end + end) + + # Receive no other values. + receive do + x -> + Logger.error("Received another value, did not want") + assert "received another value: #{inspect(x, charlists: :as_lists)} " == "" + after + 1000 -> + :ok + end + end +end diff --git a/test/to_list_test.exs b/test/to_list_test.exs new file mode 100644 index 0000000..8367116 --- /dev/null +++ b/test/to_list_test.exs @@ -0,0 +1,2 @@ +defmodule ToListTest do +end diff --git a/test/util.ex b/test/util.ex new file mode 100644 index 0000000..6cc9156 --- /dev/null +++ b/test/util.ex @@ -0,0 +1,9 @@ +defmodule Test.Util do + def sleep(ms) do + receive do + :nevergonnahappen -> :ok + after + ms -> :ok + end + end +end diff --git a/test/zip_test.exs b/test/zip_test.exs new file mode 100644 index 0000000..a52fbcd --- /dev/null +++ b/test/zip_test.exs @@ -0,0 +1,43 @@ +defmodule ZipTest do + use ExUnit.Case + alias Observables.{Obs, GenObservable} + require Logger + + @tag :zip + test "zip" do + Code.load_file("test/util.ex") + testproc = self() + + Obs.range(1, 5, 500) + |> Obs.zip(Obs.range(1, 5, 500)) + |> Obs.map(fn x -> send(testproc, x) end) + + 1..5 + |> Enum.map(fn x -> + receive do + {^x, ^x} -> Logger.debug("Got #{inspect({x, x})}") + end + end) + + Test.Util.sleep(5000) + end + + @tag :zip + test "zip uneven inputs" do + Code.load_file("test/util.ex") + testproc = self() + + Obs.range(1, 5, 500) + |> Obs.zip(Obs.range(1, 10, 500)) + |> Obs.map(fn x -> send(testproc, x) end) + + 1..5 + |> Enum.map(fn x -> + receive do + {^x, ^x} -> Logger.debug("Got #{inspect({x, x})}") + end + end) + + Test.Util.sleep(5000) + end +end