flok 0.0.40 → 0.0.41

data/spec/kern/event_spec.rb

@@ -0,0 +1,112 @@
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+
+RSpec.describe "kern:event_spec" do
+  include_context "kern"
+
+  it "Can call int_event_defer" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/controller0.rb')
+
+    #Register callout
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Queue up a deferred event
+      int_event_defer(base, "defer_res", {});
+    }
+
+    edefer_q = ctx.dump("edefer_q")
+    base = ctx.eval("base")
+    expect(edefer_q).to eq([
+      base, "defer_res", {}
+    ])
+  end
+
+  it "Does call if_dispatch with an 'i' for incomplete" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/controller0.rb')
+
+    #Register callout
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Queue up two deferred event b/c the first will get eaten
+      int_event_defer(base, "defer_res", {});
+      int_event_defer(base, "defer_res", {});
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Incomplete should have been added
+    q = @driver.dump_q
+    expect(q[0]).to eq("i")
+  end
+
+  it "Does call the event trigger for the controller after the dispatch" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/controller0defer.rb')
+
+    #Register callout
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+    }
+
+    #At this point, the synchronous event should have been dispatched in the _embed
+    #because int_event is located in the controller on_entry
+    sync_res_params = ctx.dump("sync_res_params")
+    expect(sync_res_params).to eq({
+      "foo_sync" => "bar"
+    })
+
+    #But the deferred response should only be available during the
+    #next int_disp
+    expect {
+      ctx.dump("defer_res_params")
+    }.to raise_exception
+
+    ctx.eval("int_dispatch([])")
+
+    #At this point, we only have one int_dispatch, so the event
+    #should never have been de-queued because it will on teh second one
+    defer_res_params = ctx.dump("defer_res_params")
+    expect(defer_res_params).to eq({
+      "foo" => "bar"
+    })
+  end
+
+  it "Does call the event trigger for the controller after the dispatch only one at a time" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/controller0defer2.rb')
+
+    #Register callout
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #Should have dequeued the first asynchronous event callback
+    defer_res_params = ctx.dump("defer_res_params")
+    expect(defer_res_params).to eq({
+      "foo" => "bar"
+    })
+
+    #But the second one should not have dequeued yet
+    expect {
+      ctx.dump("defer_res2_params")
+    }.to raise_exception
+
+    #Until we throw another int_dispatch
+    ctx.eval("int_dispatch([])")
+
+    #And now it should be there
+    defer_res2_params = ctx.dump("defer_res2_params")
+    expect(defer_res2_params).to eq({
+      "foo" => "bar"
+    })
+  end
+end

data/spec/kern/service_controller_spec.rb

@@ -140,7 +140,7 @@ RSpec.describe "kern:service_controller_spec" do
       int_dispatch([3, "int_event", base, "next", {}]);
     }
 
-    100.times do
+    103.times do
       @driver.int "int_timer"
     end
 
@@ -150,11 +150,23 @@ RSpec.describe "kern:service_controller_spec" do
       int_dispatch([3, "int_event", base, "next", {}]);
     }
 
+    #Should fire 25 times, but not the 26th
+    103.times do
+      @driver.int "int_timer"
+    end
+
+    #Switch back into the action
+    ctx.eval %{
+      //Drain queue
+      int_dispatch([3, "int_event", base, "next", {}]);
+      int_dispatch([3, "int_event", base, "next", {}]);
+    }
+
     100.times do
       @driver.int "int_timer"
     end
 
-    expect(ctx.eval("every_ticks")).to eq(25)
+    expect(ctx.eval("every_ticks")).to eq(50)
   end
 
   it "Does have all the right variables after sending a custom event to the service and a timer event has fired" do

data/spec/kern/vm_service_mem_pagers_spec.rb

@@ -0,0 +1,117 @@
+#The pg_mem0 pager
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require 'zlib'
+
+RSpec.describe "kern:vm_service_mem_pagers" do
+  include Zlib
+  include_context "kern"
+
+  it "Can initialize the pg_mem0 pager" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/pg_mem/config.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    res = ctx.eval("pg_mem0_spec_did_init")
+    expect(res).to eq(true)
+  end
+
+  it "Can make a write request to pg_mem0 and have that written in cache" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_mem/write.rb'), File.read("./spec/kern/assets/vm/pg_mem/config.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = ctx.dump "page"
+    vm_cache = ctx.dump("vm_cache")
+    expect(page).to eq(vm_cache["local"]["test"])
+  end
+
+  it "Can initialize the pg_mem1 pager" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/pg_mem/config1.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    res = ctx.eval("pg_mem1_spec_did_init")
+    expect(res).to eq(true)
+  end
+
+  it "Can make a write request to pg_mem1 and have that written in cache" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_mem/write.rb'), File.read("./spec/kern/assets/vm/pg_mem/config1.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = ctx.dump "page"
+    vm_cache = ctx.dump("vm_cache")
+    expect(page).to eq(vm_cache["local"]["test"])
+  end
+
+  it "Can initialize the pg_mem2 pager" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/pg_mem/config2.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    res = ctx.eval("pg_mem2_spec_did_init")
+    expect(res).to eq(true)
+  end
+
+  it "Can make a write request to pg_mem2 and have that written in cache" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_mem/write.rb'), File.read("./spec/kern/assets/vm/pg_mem/config2.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = ctx.dump "page"
+    vm_cache = ctx.dump("vm_cache")
+    expect(page).to eq(vm_cache["local"]["test"])
+  end
+
+  it "Can use pg_mem0 and pg_mem1 at the same time" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_mem/write2.rb'), File.read("./spec/kern/assets/vm/pg_mem/config3.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = ctx.dump "page"
+    page2 = ctx.dump "page2"
+    vm_cache = ctx.dump("vm_cache")
+    expect(page).to eq(vm_cache["local0"]["test"])
+    expect(page2).to eq(vm_cache["local1"]["test"])
+  end
+end

data/spec/kern/vm_service_net_sim_pager_spec.rb

@@ -0,0 +1,97 @@
+#The pg_mem0 pager
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require 'zlib'
+
+RSpec.describe "kern:vm_service_net_sim_pager" do
+  include Zlib
+  include_context "kern"
+
+  it "Can initialize the pg_net_sim pager" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_net_sim/nothing.rb'), File.read("./spec/kern/assets/vm/pg_net_sim/config.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    res = ctx.eval("pg_net_sim_spec_did_init")
+    expect(res).to eq(true)
+  end
+
+  it "Can load the pg_net_sim pager with data" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_net_sim/nothing.rb'), File.read("./spec/kern/assets/vm/pg_net_sim/config.rb") 
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      var json = #{File.read("./spec/kern/assets/vm/pg_net_sim/pages.json")};
+      pg_net_sim_load_pages(json)
+    }
+
+    pg_net_sim_stored_pages = ctx.dump("pg_net_sim_stored_pages")
+    res = ctx.eval("pg_net_sim_spec_did_init")
+    expect(res).to eq(true)
+
+    #Simulate cache build for pages, the pg_net_sim stores like vm_cache from array
+    pages = JSON.parse(File.read("./spec/kern/assets/vm/pg_net_sim/pages.json"))
+    pages_cache = {}
+    pages.each do |p|
+      pages_cache[p["_id"]] = p
+    end
+    expect(pg_net_sim_stored_pages).to eq(pages_cache)
+  end
+
+  it "Can watch pg_net_sim and not get a response back before 2 seconds (by design)" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_net_sim/watch.rb'), File.read("./spec/kern/assets/vm/pg_net_sim/config.rb") 
+    ctx.eval %{
+      var json = #{File.read("./spec/kern/assets/vm/pg_net_sim/pages.json")};
+      pg_net_sim_load_pages(json)
+
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    expect {
+      pages = JSON.parse(File.read("./spec/kern/assets/vm/pg_net_sim/pages.json"))
+      read_res_params = ctx.dump("read_res_params")
+      expect(read_res_params).to eq(pages[0])
+    }.to raise_error
+  end
+
+  it "Can watch pg_net_sim and get a response back after 2 seconds" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_net_sim/watch.rb'), File.read("./spec/kern/assets/vm/pg_net_sim/config.rb") 
+    ctx.eval %{
+      var json = #{File.read("./spec/kern/assets/vm/pg_net_sim/pages.json")};
+      pg_net_sim_load_pages(json)
+
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    (4*2).times do
+      @driver.int "int_timer"
+    end
+
+    ctx.eval "int_dispatch([]);"
+
+    pages = JSON.parse(File.read("./spec/kern/assets/vm/pg_net_sim/pages.json"))
+    read_res_params = ctx.dump("read_res_params")
+    expect(read_res_params).to eq(pages[0])
+  end
+end

data/spec/kern/vm_service_spec.rb

@@ -11,7 +11,30 @@ RSpec.describe "kern:vm_service" do
   include Zlib
   include_context "kern"
 
-it "vm_rehash_page can calculate the hash correctly" do
+  it "Contains a preloaded vm_cache, vm_dirty, and vm_notify_map for each namespace with a blank hash" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config5.rb") 
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    vm_cache = ctx.dump("vm_cache")
+    vm_dirty = ctx.dump("vm_dirty")
+    vm_notify_map = ctx.dump("vm_notify_map")
+
+    res = {
+      "spec0" => {}, 
+      "spec1" => {}
+    }
+
+    expect(vm_cache).to eq(res)
+    expect(vm_dirty ).to eq(res)
+    expect(vm_notify_map).to eq(res)
+  end
+
+  it "vm_rehash_page can calculate the hash correctly for arrays" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config3.rb") 
 
     #Run the check
@@ -19,6 +42,7 @@ it "vm_rehash_page can calculate the hash correctly" do
       //Manually construct a page
       var page = {
         _head: null,
+        _type: "array",
         _next: null,
         _id: "hello",
         entries: [
@@ -38,6 +62,7 @@ it "vm_rehash_page can calculate the hash correctly" do
     #Expect the same hash
     expect(page).to eq({
       "_head" => nil,
+      "_type" => "array",
       "_next" => nil,
       "_id" => "hello",
       "entries" => [
@@ -47,13 +72,63 @@ it "vm_rehash_page can calculate the hash correctly" do
     })
   end
 
-  it "vm_rehash_page can calculate the hash correctly with head and next" do
+  it "vm_rehash_page can calculate the hash correctly for hashes" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config3.rb") 
 
     #Run the check
     res = ctx.eval %{
       //Manually construct a page
       var page = {
+        _head: null,
+        "_type": "hash",
+        _next: null,
+        _id: "hello",
+        entries: {
+          "my_key": {_sig: "a"},
+          "my_key2": {_sig: "b"},
+          "my_key3": {_sig: "c"},
+        }
+      }
+
+      vm_rehash_page(page);
+    }
+
+    #Calculate hash ourselves
+    hash = crc32("hello")
+
+    #XOR the _sigs for the hash calculations
+    a = crc32("a", 0)
+    b = crc32("b", 0)
+    c = crc32("c", 0)
+    hash = crc32((a + b + c).to_s, hash)
+
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    #Expect the same hash
+    expect(page).to eq({
+      "_head" => nil,
+      "_next" => nil,
+      "_type" => "hash",
+      "_id" => "hello",
+      "entries" => {
+        "my_key" => {"_sig" => "a"},
+        "my_key2" => {"_sig" => "b"},
+        "my_key3" => {"_sig" => "c"},
+      },
+      "_hash" => hash.to_s
+    })
+  end
+
+
+  it "vm_rehash_page can calculate the hash correctly with head and next for an array" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config3.rb") 
+
+    #Run the check
+    res = ctx.eval %{
+      //Manually construct a page
+      var page = {
+        _type: "array",
         _head: "a",
         _next: "b",
         _id: "hello",
@@ -75,6 +150,7 @@ it "vm_rehash_page can calculate the hash correctly" do
     #Expect the same hash
     expect(page).to eq({
       "_head" => "a",
+      "_type" => "array",
       "_next" => "b",
       "_id" => "hello",
       "entries" => [
@@ -93,6 +169,7 @@ it "vm_rehash_page can calculate the hash correctly" do
       page = {
         _head: "a",
         _next: "b",
+        _type: "array",
         _id: "hello",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
@@ -167,6 +244,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: "a",
         _next: "b",
         _id: "my_key",
+        _type: "array",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
         ]
@@ -198,8 +276,8 @@ it "vm_rehash_page can calculate the hash correctly" do
     }])
   end
 
-  it "throws an exception if multiple watches are attempted" do
-    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_2watch.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+  it "does not throw an exception if multiple watches are attempted" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_2watch.rb'), File.read("./spec/kern/assets/vm/config6.rb") 
 
     expect {
       ctx.eval %{
@@ -208,11 +286,31 @@ it "vm_rehash_page can calculate the hash correctly" do
         //Drain queue
         int_dispatch([]);
       }
-    }.to raise_exception
+    }.not_to raise_exception
+
+    bp = ctx.eval("base")
+    vm_notify_map = ctx.dump("vm_notify_map")
+    vm_bp_to_nmap = ctx.dump("vm_bp_to_nmap")
+
+    expect(vm_notify_map).to eq({
+      "spec" => {
+        "test" => [bp]
+      },
+      "spec1" => {}
+    })
+
+    expect(vm_bp_to_nmap).to eq({
+      bp.to_s => {
+        "spec" => {
+          "test" => [[bp], 0]
+        }
+      }
+    })
+
   end
 
-  it "throws an exception if unwatch is called before watch" do
-    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_ewatch.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+  it "does not throw an exception if multiple unwatches are requested" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_ewatch.rb'), File.read("./spec/kern/assets/vm/config6.rb") 
 
     expect {
       ctx.eval %{
@@ -221,7 +319,95 @@ it "vm_rehash_page can calculate the hash correctly" do
         //Drain queue
         int_dispatch([]);
       }
-    }.to raise_exception
+    }.not_to raise_exception
+
+    bp = ctx.eval("base")
+    vm_notify_map = ctx.dump("vm_notify_map")
+    vm_bp_to_nmap = ctx.dump("vm_bp_to_nmap")
+
+    expect(vm_notify_map).to eq({
+      "spec" => {
+      },
+      "spec1" => {}
+    })
+
+    expect(vm_bp_to_nmap).to eq({
+      bp.to_s  => {}
+    })
+
+  end
+
+  it "does not throw an exception if unwatch is called before watch on a particular controller; but it was already watched at one point" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_ewatch2.rb'), File.read("./spec/kern/assets/vm/config6.rb") 
+
+    expect {
+      ctx.eval %{
+        base = _embed("my_watch_controller", 1, {}, null);
+        base = _embed("my_controller", 1, {}, null);
+
+        //Drain queue
+        int_dispatch([]);
+      }
+    }.not_to raise_exception
+  end
+
+  it "does allow watch, unwatch, and then re-watch to work" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_ewatch3.rb'), File.read("./spec/kern/assets/vm/config6.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    bp = ctx.eval("base")
+    vm_notify_map = ctx.dump("vm_notify_map")
+    vm_bp_to_nmap = ctx.dump("vm_bp_to_nmap")
+
+    expect(vm_notify_map).to eq({
+      "spec" => {
+        "test" => [bp]
+      },
+      "spec1" => {}
+    })
+
+    expect(vm_bp_to_nmap).to eq({
+      bp.to_s => {
+        "spec" => {
+          "test" => [[bp], 0]
+        }
+      }
+    })
+  end
+
+  it "does allow unwatch, watch, and then re-unwatch to work" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller_exc_ewatch4.rb'), File.read("./spec/kern/assets/vm/config6.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    bp = ctx.eval("base")
+    vm_notify_map = ctx.dump("vm_notify_map")
+    vm_bp_to_nmap = ctx.dump("vm_bp_to_nmap")
+
+    expect(vm_notify_map).to eq({
+      "spec" => {
+        "test" => []
+      },
+      "spec1" => {}
+    })
+
+    expect(vm_bp_to_nmap).to eq({
+      bp.to_s => {
+        "spec" => {
+        }
+      }
+    })
   end
 
   it "multiple sequential watch requests from two controllers for a namespace do not hit the pager multiple times" do
@@ -312,17 +498,30 @@ it "vm_rehash_page can calculate the hash correctly" do
     expect(read_res_params).to eq(vm_write_list)
   end
 
-  it "does send two watch callbacks to a controller if there is cached content" do
+  it "non-sync watch does send two watch callbacks to a controller if there is cached content" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller12.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
 
     ctx.eval %{
       base = _embed("my_controller", 1, {}, null);
-
-      //Drain queue
-      int_dispatch([]);
     }
 
+    #Should not have read anything at this point in time
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    expect(read_res_params.length).to eq(0)
+
+    ctx.eval("int_dispatch([])")
+
+    #Now we read the first after it de-queued
     read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    expect(read_res_params.length).to eq(1)
+
+    ctx.eval("int_dispatch([])")
+
+    #And now the second
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    expect(read_res_params.length).to eq(2)
+
+    #And they should have been read in order
     vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list)"));
     expect(read_res_params).to eq(vm_write_list)
   end
@@ -439,6 +638,30 @@ it "vm_rehash_page can calculate the hash correctly" do
     })
   end
 
+  it "Does not crash when a new a controller disconnects without watches" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller16b.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([3, "int_event", base, "next", {}]);
+    }
+
+    #vm_bp_To_nmap should be blank
+    base = ctx.eval("base")
+    vm_bp_to_nmap = JSON.parse(ctx.eval("JSON.stringify(vm_bp_to_nmap)"));
+    expect(vm_bp_to_nmap).to eq({})
+
+    #vm_notify_map should not contain the entries for the base address anymore
+    base = ctx.eval("base")
+    vm_notify_map = JSON.parse(ctx.eval("JSON.stringify(vm_notify_map)"));
+    expect(vm_notify_map).to eq({
+      "spec" => {
+      }
+    })
+  end
+
   it "Erases entries in vm_bp_to_nmap and vm_notify_map for a controller that disconnects" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller16.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
 
@@ -499,6 +722,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: "a",
         _next: "b",
         _id: "hello",
+        _type: "array",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
         ]
@@ -703,7 +927,63 @@ it "vm_rehash_page can calculate the hash correctly" do
     })
   end
 
-  it "Responds twice to watch with a missing cache but where the disk has a copy and then the pager responds" do
+  #it "Responds twice to watch with a missing cache but where the disk has a copy and then the pager responds" do
+    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller20.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    #ctx.eval %{
+      #base = _embed("my_controller", 1, {}, null);
+
+      #//Manually construct a page
+      #page = {
+        #_head: null,
+        #_next: null,
+        #_id: "hello",
+        #entries: [
+          #{_id: "hello2", _sig: "nohteunth"},
+        #]
+      #}
+
+      #//Manually construct another page that would normally be written
+      #//by a 'pager' to the cache
+      #page2 = {
+        #_head: null,
+        #_next: null,
+        #_id: "hello",
+        #entries: [
+          #{_id: "hello2", _sig: "nohteunth"},
+          #{_id: "hello3", _sig: "athoeuntz"}
+        #]
+      #}
+
+      #//Recalculate hashes
+      #vm_rehash_page(page);
+      #vm_rehash_page(page2);
+
+      #//Drain queue
+      #int_dispatch([]);
+    #}
+
+    ##Copies of JS pages in ruby dictionary format
+    #page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    #page2 = JSON.parse(ctx.eval("JSON.stringify(page2)"))
+
+    ##At this point, flok should have attempted to grab a page to fill
+    ##the *now* blank cache. We are going to send it the first page.
+    #@driver.ignore_up_to "if_per_get", 2
+    #@driver.get "if_per_get", 2
+    #@driver.int "int_per_get_res", ["vm", "spec", page]
+
+    ##Now, we pretend that a pager has written to the cache because it has
+    ##received data back
+    #ctx.eval(%{vm_cache_write("spec", page2)})
+
+    #res = JSON.parse(ctx.eval("JSON.stringify(read_res)"))
+    #expect(res).to eq([
+      #page, page2
+    #])
+ #end
+
+ it "Responds once to watch with a missing cache but where the pager responds before the disk for array" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller20.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
 
     ctx.eval %{
@@ -714,6 +994,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: null,
         _next: null,
         _id: "hello",
+        _type: "array",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
         ]
@@ -725,6 +1006,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: null,
         _next: null,
         _id: "hello",
+        _type: "array",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
           {_id: "hello3", _sig: "athoeuntz"}
@@ -747,19 +1029,22 @@ it "vm_rehash_page can calculate the hash correctly" do
     #the *now* blank cache. We are going to send it the first page.
     @driver.ignore_up_to "if_per_get", 2
     @driver.get "if_per_get", 2
-    @driver.int "int_per_get_res", ["vm", "spec", page]
 
     #Now, we pretend that a pager has written to the cache because it has
     #received data back
     ctx.eval(%{vm_cache_write("spec", page2)})
 
+    #And then we let the cache from disk reply, which should be ignored
+    #because the cache is already there from the pager
+    @driver.int "int_per_get_res", ["vm", "spec", page]
+
     res = JSON.parse(ctx.eval("JSON.stringify(read_res)"))
     expect(res).to eq([
-      page, page2
+      page2
     ])
- end
+  end
 
- it "Responds once to watch with a missing cache but where the pager responds before the disk" do
+ it "Responds once to watch with a missing cache but where the pager responds before the disk for hash" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/controller20.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
 
     ctx.eval %{
@@ -770,6 +1055,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: null,
         _next: null,
         _id: "hello",
+        _type: "hash",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
         ]
@@ -781,6 +1067,7 @@ it "vm_rehash_page can calculate the hash correctly" do
         _head: null,
         _next: null,
         _id: "hello",
+        _type: "hash",
         entries: [
           {_id: "hello2", _sig: "nohteunth"},
           {_id: "hello3", _sig: "athoeuntz"}