reset test cases

src/stores/kvs_st.erl

@@ -17,7 +17,8 @@ id(T) -> e(#it.id, T).
 k(F,[]) -> key(F);
 k(_,{_,Id,SF}) -> key(SF,Id).
 
-read_it(C,{ok,F,V,H}) -> C#reader{cache={e(1,V),id(V),F}, args=lists:reverse(H)};
+read_it(C,{ok,_,[],H}) -> C#reader{cache=[], args=lists:reverse(H)};
+read_it(C,{ok,F,V,H})  -> C#reader{cache={e(1,V),id(V),F}, args=lists:reverse(H)};
 read_it(C,_) -> C.
 
 top(#reader{feed=Feed}=C) -> #writer{count=Cn} = writer(Feed), read_it(C#reader{count=Cn},seek_it(key(Feed))).

test/fd_test.exs

@@ -0,0 +1,32 @@
+ExUnit.start()
+
+defmodule Fd.Test do
+    use ExUnit.Case, async: true
+    require KVS
+    import Record
+
+    defrecord(:msg, id: [], body: [])
+
+    setup do: (on_exit(fn -> :ok = :kvs.leave();:ok = :kvs.destroy() end);:kvs.join())
+    setup kvs, do: [
+        id0: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), "/crm/duck") end, :lists.seq(1,10)),
+        id1: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), "/crm/luck") end, :lists.seq(1,10)),
+        id2: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), "/crm/truck") end, :lists.seq(1,10)),
+        ]
+
+    test "reader", kvs do
+        ltop = Enum.at(kvs[:id1],0)
+        dtop = Enum.at(kvs[:id0],0)
+        ttop = Enum.at(kvs[:id2],0)
+        assert KVS.reader(feed: "/crm/luck", count: 10, dir: 0, args: [], cache: {:msg, ^ltop, "/crm/luck"}) = :kvs.reader("/crm/luck")
+        assert KVS.reader(feed: "/crm/duck", count: 10, dir: 0, args: [], cache: {:msg, ^dtop, "/crm/duck"}) = :kvs.reader("/crm/duck")
+        assert KVS.reader(feed: "/crm/truck", count: 10, dir: 0, args: [], cache: {:msg, ^ttop, "/crm/truck"}) = :kvs.reader("/crm/truck")
+        assert KVS.reader(feed: "/crm", count: 0, dir: 0, args: [], cache: {:msg, ^dtop, "/crm/duck"}) = :kvs.reader("/crm")
+        assert KVS.reader(feed: "/noroute", count: 0, dir: 0, args: []) = :kvs.reader("/noroute")
+        assert KVS.reader(feed: "/", count: 0, dir: 0, args: [], cache: {:msg, ^dtop, "/crm/duck"}) = :kvs.reader("/")
+        assert KVS.reader(feed: "", count: 0, dir: 0, args: [], cache: []) = :kvs.reader([])
+    end
+
+    defp log(x), do: IO.puts '#{inspect(x)}'
+    defp log(m, x), do: IO.puts '#{m} #{inspect(x)}'
+end

test/old_test.exs

@@ -1,326 +0,0 @@
-ExUnit.start()
-
-defmodule OLD.Test do
-  use ExUnit.Case, async: true
-  require KVS
-
-  setup do: (on_exit(fn -> :ok = :kvs.leave();:ok = :kvs.destroy() end);:kvs.join())
-
-  test "basic" do
-    id1 = "/basic/one"
-    id2 = "/basic/two"
-    x = 5
-    :kvs.save(:kvs.writer(id1))
-    :kvs.save(:kvs.writer(id2))
-
-    :lists.map(
-      fn _ ->
-        :kvs.save(:kvs.add(KVS.writer(:kvs.writer(id1), args: {:"$msg", [], [], [], [], []})))
-      end,
-      :lists.seq(1, x)
-    )
-
-    :lists.map(fn _ -> :kvs.append({:"$msg", [], [], [], [], []}, id2) end, :lists.seq(1, x))
-    r1 = :kvs.save(:kvs.reader(id1))
-    r2 = :kvs.save(:kvs.reader(id2))
-    x1 = :kvs.take(KVS.reader(:kvs.load_reader(KVS.reader(r1, :id)), args: 20))
-    x2 = :kvs.take(KVS.reader(:kvs.load_reader(KVS.reader(r2, :id)), args: 20))
-    b = :kvs.feed(id1)
-
-    case :application.get_env(:kvs, :dba_st, :kvs_st) do
-      :kvs_st ->
-        c = :kvs.all("/basic/two")
-        assert :lists.reverse(c) == KVS.reader(x2, :args)
-      _ ->
-        # mnesia doesn't support `all` over feeds (only for tables)
-        []
-    end
-
-    assert KVS.reader(x1, :args) == b
-
-    assert length(KVS.reader(x1, :args)) == length(KVS.reader(x2, :args))
-    assert x == length(b)
-  end
-
-  test "sym" do
-    id = {:sym, :kvs.seq([], [])}
-    :kvs.save(:kvs.writer(id))
-    x = 5
-
-    :lists.map(
-      fn
-        z ->
-          :kvs.remove(KVS.writer(z, :cache), id)
-      end, :lists.map(
-        fn _ ->
-          :kvs.save(:kvs.add(KVS.writer(:kvs.writer(id), args: {:"$msg", [], [], [], [], []})))
-        end,
-        :lists.seq(1, x)
-      )
-    )
-
-    {:ok, KVS.writer(count: 0)} = :kvs.get(:writer, id)
-  end
-
-  test "take" do
-    feed = :partial
-    x = 5
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", [], [], [], [], []}, feed) end, :lists.seq(1, x))
-    KVS.reader(id: rid) = :kvs.save(:kvs.reader(feed))
-    t = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: 20))
-    b = :kvs.feed(feed)
-    #: mnesia
-    assert KVS.reader(t, :args) == b
-  end
-
-  test "take back full" do
-    log(:st, "take back full")
-    feed = :partial
-    x = 5
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", [], [], [], [], []}, feed) end, :lists.seq(1, x))
-    KVS.reader(id: rid) = :kvs.save(:kvs.reader(feed))
-    t = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: 5))
-    :kvs.save(KVS.reader(t, dir: 1))
-    log("t:", t)
-    n = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: 5))
-    b = :kvs.feed(feed)
-    log("n:", n)
-    assert KVS.reader(n, :args) == KVS.reader(t, :args)
-    assert KVS.reader(t, :args) == b
-    log(:end, "take back full")
-  end
-
-  test "partial take back" do
-    feed = :partial
-    x = 3
-    p = 2
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", [], [], [], [], []}, feed) end, :lists.seq(1, x))
-    KVS.reader(id: rid) = :kvs.save(:kvs.reader(feed))
-    t = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    :kvs.save(KVS.reader(t, dir: 1))
-    n = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p + 1))
-    assert KVS.reader(t, :args) == tl(KVS.reader(n, :args))
-  end
-
-  test "partial full bidirectional" do
-    log(:st, "partial full bidirectional")
-    feed = :partial
-    x = 5
-    p =2
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", :kvs.seq([],[]), [], [], [], []}, feed) end, :lists.seq(1, x))
-    r = :kvs.save(:kvs.reader(feed))
-    rid = KVS.reader(r, :id)
-    t1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p, dir: 0))
-    z1 = KVS.reader(t1, :args)
-    IO.inspect :kvs.all(feed)
-    r = :kvs.save(t1)
-    log("next t1:", t1)
-
-    t2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z2 = KVS.reader(t2, :args)
-    r = :kvs.save(t2)
-    log("next t2:", t2)
-
-    t3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z3 = KVS.reader(t3, :args)
-    :kvs.save(KVS.reader(t3, dir: 1, pos: 0))
-    log("next t3:", t3)
-
-    n1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz1 = KVS.reader(n1, :args)
-    :kvs.save n1
-    log("prev n1:", n1)
-
-    n2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz2 = KVS.reader(n2, :args)
-    :kvs.save n2
-    log("prev n2:", n2)
-
-    n3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz3 = KVS.reader(n3, :args)
-    log("prev n3:", n3)
-
-    assert z3 ++ z2 ++ z1 == nz1 ++ nz2 ++ nz3
-    log(:end, "partial full bidirectional")
-  end
-
-  test "test bidirectional (new)" do
-    log(:st, "test bidirectional (new)")
-    feed = :partial
-    x = 6
-    p = 3
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", :kvs.seq([],[]), [], [], [], []}, feed) end, :lists.seq(1, x))
-    r = :kvs.save(:kvs.reader(feed))
-    rid = KVS.reader(r, :id)
-    IO.inspect :kvs.all(feed)
-
-    t1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p, dir: 0))
-    z1 = KVS.reader(t1, :args)
-    r = :kvs.save(t1)
-    log("next t1:", t1)
-
-    t2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z2 = KVS.reader(t2, :args)
-    r = :kvs.save(t2)
-    log("next t2:", t2)
-
-    t3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z3 = KVS.reader(t3, :args)
-    :kvs.save(KVS.reader(t3, dir: 1, pos: 0))
-    log("next t3:", t3)
-
-    assert z3 == []
-
-    n1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz1 = KVS.reader(n1, :args)
-    :kvs.save n1
-    log("prev n1:", n1)
-
-    n2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz2 = KVS.reader(n2, :args)
-    :kvs.save n2
-    log("prev n2:", n2)
-
-    n3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    nz3 = KVS.reader(n3, :args)
-    :kvs.save(KVS.reader(n3, dir: 0))
-    log("prev n3:", n3)
-
-    assert nz3 == []
-
-    t4 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p, dir: 0))
-    z4 = KVS.reader(t4, :args)
-    r = :kvs.save(t4)
-    log("next t4:", t4)
-
-    assert length(z4) == p
-    log(:end, "test bidirectional (new)")
-  end
-
-  test "partial take forward full" do
-    log(:st, "partial take forward full")
-    feed = :partial
-    x = 7
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", [], [], [], [], []}, feed) end, :lists.seq(1, x))
-    KVS.reader(id: rid) = :kvs.save(:kvs.reader(feed))
-    p = 3
-    IO.inspect :kvs.all(feed)
-
-    t1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z1 = KVS.reader(t1, :args)
-    :kvs.save(t1)
-    log("next t1:", t1)
-
-    t2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z2 = KVS.reader(t2, :args)
-    :kvs.save(t2)
-    log("next t2:", t2)
-
-    t3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z3 = KVS.reader(t3, :args)
-    :kvs.save(t3)
-    log("next t3:", t3)
-
-    assert length(z3) == 1
-    assert :lists.reverse(z1) ++ :lists.reverse(z2) ++ z3 == :kvs.all(:partial)
-    log(:end, "partial take forward full")
-  end
-
-  test "take with empy" do
-    log(:st, "take with empy")
-    feed = :partial
-    x = 6
-    p = 3
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", :kvs.seq([],[]), [], [], [], []}, feed) end, :lists.seq(1, x))
-    r = :kvs.save(:kvs.reader(feed))
-    IO.inspect :kvs.all(feed)
-    rid = KVS.reader(r, :id)
-    t1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p, dir: 0))
-    z1 = KVS.reader(t1, :args)
-    r = :kvs.save(t1)
-    log("next t1:", t1)
-
-    t2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z2 = KVS.reader(t2, :args)
-    r = :kvs.save(t2)
-    log("next t2:", t2)
-
-    t3 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z3 = KVS.reader(t3, :args)
-    r = :kvs.save(t3)
-    log("next t3:", t3)
-    assert  z3 == []
-
-    KVS.reader(id: tid) = :kvs.save(KVS.reader(t3, dir: 1, pos: 0))
-    n1 = :kvs.take(KVS.reader(:kvs.load_reader(tid), args: p))
-    nz1 = KVS.reader(n1, :args)
-    :kvs.save n1
-    log("prev b1:", n1)
-
-    n2 = :kvs.take(KVS.reader(:kvs.load_reader(tid), args: p))
-    nz2 = KVS.reader(n2, :args)
-    :kvs.save n2
-    log("prev b2:", n2)
-
-    assert z2 ++ z1 == nz1 ++ nz2
-    log(:end, "take with empy")
-  end
-
-  test "test prev" do
-    log(:st, "test prev")
-    feed = :partial
-    x = 6
-    p = 3
-    :kvs.save(:kvs.writer(feed))
-    :lists.map(fn _ -> :kvs.append({:"$msg", :kvs.seq([],[]), [], [], [], []}, feed) end, :lists.seq(1, x))
-    r = :kvs.save(:kvs.reader(feed))
-    rid = KVS.reader(r, :id)
-    IO.inspect :kvs.all(feed)
-
-    t1 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p, dir: 0))
-    z1 = KVS.reader(t1, :args)
-    r = :kvs.save(t1)
-    log("next z1:", z1)
-
-    t2 = :kvs.take(KVS.reader(:kvs.load_reader(rid), args: p))
-    z2 = KVS.reader(t2, :args)
-
-    KVS.reader(id: tid) = :kvs.save(KVS.reader(t2, dir: 1, pos: 0))
-    log("next z2:", z2)
-
-    n1 = :kvs.take(KVS.reader(:kvs.load_reader(tid), args: p))
-    nz1 = tl(:lists.reverse(KVS.reader(n1, :args)))
-    :kvs.save(n1)
-    log("prev nz1:", nz1)
-
-    n2 = :kvs.take(KVS.reader(:kvs.load_reader(tid), args: p))
-    nz2 = KVS.reader(n2, :args)
-    :kvs.save n2
-    log("prev n2:", n2)
-
-    assert length(nz2) == p
-    assert nz2 == z1
-
-    n3 = :kvs.take(KVS.reader(:kvs.load_reader(tid), args: p))
-    nz3 = KVS.reader(n3, :args)
-    :kvs.save(KVS.reader(n3, dir: 0))
-    log("prev nz3:", nz3)
-
-    assert nz3 = []
-
-    log(:end, "test prev")
-
-  end
-
-  def log(x,cursor) do
-     IO.inspect {x,cursor}
-  end
-end
-

test/st_test.exs

@@ -1,11 +1,12 @@
 ExUnit.start()
 
-defmodule ST.Test do
+defmodule St.Test do
     use ExUnit.Case, async: false
     import Record
     require KVS
 
     defrecord(:msg, id: [], body: [])
+
     setup do: (on_exit(fn -> :ok = :kvs.leave();:ok = :kvs_rocks.destroy() end);:kvs.join())
     setup kvs, do: [
         ids: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), :feed) end, :lists.seq(1,10)),
@@ -13,60 +14,6 @@ defmodule ST.Test do
         id1: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), "/crm/personal/Реєстратор А1/in/mail") end, :lists.seq(1,10)),
         id2: :lists.map(fn _ -> :kvs.append(msg(id: :kvs.seq([],[])), "/crm/personal/Реєстратор А1/in/doc") end, :lists.seq(1,10))]
 
-    test "al0", kvs, do: assert kvs[:ids] |> Enum.map(&msg(id: &1)) == :kvs.all(:feed)
-    test "al1", kvs, do: assert (kvs[:id0] ++ kvs[:id2] ++ kvs[:id1]) |> Enum.map(&msg(id: &1)) == :kvs.all("/crm/personal/Реєстратор А1/in")
-    
-    #: old behaviour is reversed ? 
-    test "fe0", kvs, do: assert kvs[:ids] |> Enum.reverse |> Enum.map(&msg(id: &1)) == :kvs.feed(:feed)
-
-    #: real cache {:feed, :msg, id}
-    test "top",  kvs, do: (r0=:kvs.reader(:feed); assert KVS.reader(r0, cache: {:msg, Enum.at(kvs[:ids],0), "/feed"}, dir: 0) == :kvs.top(r0))
-    test "bot",  kvs, do: (r0=:kvs.reader(:feed); assert KVS.reader(r0, cache: {:msg, Enum.at(kvs[:ids],9), "/feed"}, dir: 1) == :kvs.bot(r0))
-    
-    test "next", kvs do
-        KVS.reader(id: rid) = :kvs.save(:kvs.top(:kvs.reader(:feed)))
-        kvs[:ids] |> Enum.each(&assert(KVS.reader(cache: {:msg,&1,"/feed"}) = :kvs.next(:kvs.load_reader(rid))))
-    end
-
-    test "prev", kvs do
-        KVS.reader(id: rid) = :kvs.save(:kvs.bot(:kvs.reader(:feed)))
-        kvs[:ids] |> Enum.reverse |> Enum.each(&assert KVS.reader(cache: {:msg,&1,"/feed"}) = :kvs.prev(:kvs.load_reader(rid)))
-    end
-   
-
-    test "take-ø", kvs do
-        r = KVS.reader() = :kvs.reader("/empty-feed")
-        assert r1 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(r, args: 1))
-        assert r1 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(r, args: 1, dir: 1))
-        assert r2 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.next(r)
-        assert r3 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.prev(r)
-        assert r1 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(r, args: 100))
-        assert r1 = KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(r, args: 100, dir: 1))
-        KVS.reader(id: rid) = :kvs.save(r1)
-        assert rs1 = KVS.reader(id: rid) = :kvs.load_reader(rid)
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(rs1, args: 5))
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(rs1, args: 5, dir: 1))
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.next(rs1)
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.prev(rs1)
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(rs1, args: 0))
-        assert KVS.reader(feed: "/empty-feed", args: []) = :kvs.take(KVS.reader(rs1, args: 0, dir: 1))
-    end
-
-    test "drop", kvs do
-        assert r = KVS.reader(id: rid, args: [], cache: c0) = :kvs.save(:kvs.reader(:feed))
-        assert r1 = KVS.reader(id: ^rid, feed: :feed, args: []) = :kvs.drop(KVS.reader(r,  args: 10, dir: 0))
-
-        kvs[:ids] |> Enum.map(&msg(id: &1)) 
-                  |> Enum.each(&assert(KVS.reader(id: rid, feed: :feed, args: [], cache: &1) = :kvs.save(:kvs.drop(KVS.reader(:kvs.load_reader(rid), args: 1, dir: 0)))))
-
-        assert r2 = KVS.reader(id: ^rid, feed: :feed, args: [], cache: c1) = :kvs.drop(KVS.reader(r, args: 1, dir: 0))
-        assert {:msg, Enum.at(kvs[:ids], 1)} == c1
-        assert r3 = KVS.reader(id: ^rid, feed: :feed, args: [], cache: c2) = :kvs.drop(KVS.reader(r2, args: 5, dir: 0))
-        assert {:msg, Enum.at(kvs[:ids], 6)} == c2
-        assert r4 = KVS.reader(id: ^rid, feed: :feed, args: [], cache: c3) = :kvs.drop(KVS.reader(r1, args: 100))
-        assert {:msg, Enum.at(kvs[:ids],9)} == c3
-    end
-
     defp log(x), do: IO.puts '#{inspect(x)}'
     defp log(m, x), do: IO.puts '#{m} #{inspect(x)}'