flok 0.0.38 → 0.0.39

data/spec/kern/controller_macro_spec.rb

@@ -0,0 +1,186 @@
+#This was created later than the controllers, so not all macros may be 
+#tested in here.  Additionally, some macros may be harder to test, so 
+#this contains mostly non-side-effect (functionalish) macros that do not
+#make other function calls. e.g. vm page macros
+
+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:controller_macro_spec" do
+  include_context "kern"
+
+  it "Can use the NewPage macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/new_page_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #Check the page variable 
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    expect(page).to eq({
+      "_head" =>  nil,
+      "_next" =>  nil,
+      "entries" => [],
+      "_id" => nil
+    })
+  end
+
+  it "Can use the NewPage macro with id" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/new_page_c2.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #Check the page variable 
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    expect(page).to eq({
+      "_head" =>  nil,
+      "_next" =>  nil,
+      "entries" => [],
+      "_id" => "test"
+    })
+  end
+
+  it "Can use the CopyPage macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/copy_page_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    not_copied_page = JSON.parse(ctx.eval("JSON.stringify(not_copied_page)"))
+    copied_page = JSON.parse(ctx.eval("JSON.stringify(copied_page)"))
+
+    #What the copied page should look like after a copy
+    copied_should_look_like = JSON.parse(original_page.to_json)
+    copied_should_look_like["_next"] = "test" #Set in controller
+    copied_should_look_like.delete "_hash"
+
+    expect(not_copied_page).to eq(original_page)
+    expect(copied_page).to eq(copied_should_look_like)
+  end
+
+  it "Can use the EntryDel macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_del_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    expect(page).to eq({
+      "_head" => "head",
+      "_id" => "id",
+      "_next" => "next",
+      "entries" => []
+    })
+
+    expect(original_page).to eq({
+      "_head" => "head",
+      "_id" => "id",
+      "_next" => "next",
+      "entries" => [{
+        "_id" => "id", "_sig" => "sig"
+      }],
+      "_hash" => "hash"
+    })
+  end
+
+  it "Can use the EntryInsert macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_insert_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    expect(page["entries"].count).to eq(3)
+    expect(page["entries"][0]["hello"]).to eq("world")
+    expect(page["entries"][2]["hello"]).to eq("world2")
+
+    expect(page["entries"][0]["_sig"]).not_to eq(nil)
+    expect(page["entries"][0]["_sig"]).not_to eq(page["entries"][1]["_sig"])
+    expect(page["entries"][0]["_id"]).not_to eq(nil)
+    expect(page["entries"][2]["_id"]).not_to eq(page["entries"][0]["_id"])
+    expect(page["entries"][2]["_id"]).not_to eq(page["entries"][1]["_id"])
+  end
+
+  it "Can use the EntryMutable macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_mutable_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    entries = page["entries"]
+    original_entries = original_page["entries"]
+    expect(entries[0]["hello"]).to eq("world")
+    expect(entries[0]["foo"]).to eq(nil)
+    expect(entries[2]["hello"]).to eq("world")
+    expect(entries[2]["foo"]).to eq(nil)
+
+    #Shared
+    expect(entries[1]["foo"]).to eq("bar")
+    expect(entries[1]["hello"]).to eq(nil)
+
+    #This should remain unchanged
+    expect(original_page["entries"]).to eq([
+      {"_id" => "id", "_sig" => "sig"},
+      {"_id" => "id2", "_sig" => "sig2", "foo" => "bar"},
+      {"_id" => "id3", "_sig" => "sig3"},
+    ])
+  end
+
+  it "Can use the SetPageNext macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/set_page_next_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    expect(page["_next"]).to eq("test")
+  end
+
+  it "Can use the SetPageHead macro" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/set_page_head_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    expect(page["_head"]).to eq("test")
+  end
+end

data/spec/kern/dispatch_spec.rb

@@ -0,0 +1,125 @@
+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:dispatch_spec" do
+  #Max number of items to be queued in queues other than main
+  #per dispatch (as per specs)
+  MAX_Q = 5
+  
+  include_context "kern"
+
+  it "Can call spec_dispatch" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+    #Register callout
+    ctx.eval %{
+      spec_dispatch_q(main_q, 2);
+    }
+
+    main_q = ctx.dump "main_q"
+    expect(main_q).to eq [[0, "spec"], [0, "spec"]]
+  end
+
+  it "Does disptach an unlimited number of items from the main queue" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+    #Register callout
+    ctx.eval %{
+      spec_dispatch_q(main_q, 10);
+    }
+
+    ctx.eval("int_dispatch([])")
+    q = @driver.dump_q
+
+    expect(q).to eq([[0, [0, "spec"]*10].flatten])
+  end
+
+  queues = [
+    "main",
+    "net",
+    "disk",
+    "cpu",
+    "gpu"
+  ]
+
+  queues.each_with_index do |qname, qindex|
+    #Don't do main queue
+    next if qname == "main"
+    
+    it "Does not disptach an unlimited number of items from the #{qname} queue" do
+      #Compile the controller
+      ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+      #Register callout
+      ctx.eval %{
+        spec_dispatch_q(#{qname}_q, #{MAX_Q+1});
+      }
+
+      #Get partial queue, should have 'i' because we want more things than the max
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+      expect(q).to eq(['i', [qindex, [0, "spec"]*MAX_Q].flatten])
+    end
+
+    it "Does dispatch the rest of the items after the first two incomplete disptaches" do
+      #Compile the controller
+      ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+      #Register callout
+      ctx.eval %{
+        spec_dispatch_q(#{qname}_q, #{MAX_Q*3});
+      }
+
+      #Get partial queue, should have 'i' because we want more things than the max
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+      expect(q).to eq(['i', [qindex, [0, "spec"]*MAX_Q].flatten])
+
+      #Get partial queue, should have 'i' because we want more things than the max
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+      expect(q).to eq(['i', [qindex, [0, "spec"]*MAX_Q].flatten])
+
+      #Last piece, should not have an 'i'
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+      expect(q).to eq([[qindex, [0, "spec"]*MAX_Q].flatten])
+    end
+
+
+    it "Does disptach at MAX_Q number of items from the #{qname} queue" do
+      #Compile the controller
+      ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+      #Register callout
+      ctx.eval %{
+        spec_dispatch_q(#{qname}_q, #{MAX_Q});
+      }
+
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+
+      expect(q).to eq([[qindex, [0, "spec"]*MAX_Q].flatten])
+    end
+
+    it "Does disptach all at (MAX_Q-1) number of items from the #{qname} queue" do
+      #Compile the controller
+      ctx = flok_new_user File.read('./spec/kern/assets/blank.rb')
+
+      #Register callout
+      ctx.eval %{
+        spec_dispatch_q(#{qname}_q, #{MAX_Q}-1);
+      }
+
+      ctx.eval("int_dispatch([])")
+      q = @driver.dump_q
+
+      expect(q).to eq([[qindex, [0, "spec"]*(MAX_Q-1)].flatten])
+    end
+  end
+end

data/spec/kern/functions_spec.rb

@@ -26,4 +26,19 @@ RSpec.describe "kern:functions_spec" do
     expect(res).not_to eq(res2)
   end
 
+ it "can use gen_id" do
+    ctx = flok_new_user File.read('./spec/kern/assets/controller0.rb')
+
+    #Run the check
+    res = ctx.eval("gen_id()")
+    res2 = ctx.eval("gen_id()")
+    reset_for_ctx
+
+    ctx2 = flok_new_user File.read('./spec/kern/assets/controller0.rb')
+
+    res3 = ctx2.eval("gen_id()")
+    expect(res.class).to eq(String)
+    expect(res).not_to eq(res2)
+    expect(res3).not_to eq(res)
+  end
 end

data/spec/kern/vm_service_spec.rb

@@ -5,191 +5,892 @@ 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" do
+  include Zlib
   include_context "kern"
 
- #it "Can be used inside a controller" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config0.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    #base = ctx.eval("base")
-    #res = ctx.eval("vm_did_wakeup")
-    #expect(res).to eq(true)
-  #end
-
- #it "Does pass options to spec0 in init" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    #base = ctx.eval("base")
-    #res = JSON.parse(ctx.eval("JSON.stringify(spec0_init_options)"))
-    #expect(res).to eq({"hello" => "world"})
-  #end
-
- #it "Can include the spec0 pager and call read_sync" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller1.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    ##Verify that the vm service is getting the read_sync request
-    #res = ctx.eval("vm_read_sync_called")
-    #expect(res).to eq(true)
-
-    ##Verify that the vm service is disptaching the request
-    #res = ctx.eval("spec0_read_sync_called")
-    #expect(res).to eq(true)
-  #end
-
-  #it "Can include the spec0 pager and call read_sync and then get a reply" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller1.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    ##Verify that the read did return from the spec0 pager
-    #res = ctx.eval("read_res_params")
-    #expect(res).not_to eq(nil)
-  #end
-
-
-  #it "Can include the spec0 pager and call read and then get a reply" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller2.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    ##Verify that the read did return from the spec0 pager
-    #res = ctx.eval("read_res_params")
-    #expect(res).not_to eq(nil)
-  #end
-
-  #it "Can include the spec0 pager and call write and and then read to get a reply" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller3.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    ##Verify that the read did return from the spec0 pager
-    #res = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
-    #expect(res).to eq({
-      #"key" => 33,
-      #"value" => 22
-    #})
-  #end
-
-#  it "Write then read does will hit the pager for the read, a write is not guaranteed to be 1 to 1 but a read is, additionally, the reads only went through once" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller4.rb'), File.read("./spec/kern/assets/vm/config1.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    #expect(ctx.eval("spec0_read_count")).to eq(1)
-  #end
-
-  #it "Can read through and then send another read_res for a change on the page" do
-    ##Compile the controller
-    #ctx = flok_new_user File.read('./spec/kern/assets/vm/controller5.rb'), File.read("./spec/kern/assets/vm/config2.rb")
-
-    ##Run the embed function
-    #ctx.eval %{
-      #//Call embed on main root view
-      #base = _embed("my_controller", 0, {}, null);
-
-      #//Drain queue
-      #int_dispatch([]);
-    #}
-
-    ##read_res from spec is called multiple times and returns an array of the parms
-    #res = JSON.parse(ctx.eval("JSON.stringify(read_res_called_with)"))
-
-    ##Expect 2 responses, first is cache miss, second is cache hit, third is cache updated
-    #expect(res).to eq [
-      #{"key" => "my_key", "value" => "a"},
-      #{"key" => "my_key", "value" => "a"},
-      #{"key" => "my_key", "value" => "b"}
-    #]
-  #end
-
-  it "Can watch a key and then be sent a read_res whenever that key changes" do
-    #Compile the controller
-    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller6.rb'), File.read("./spec/kern/assets/vm/config3.rb")
-
-    #Run the embed function
-    ctx.eval %{
-      //Call embed on main root view
+ it "vm_rehash_page can calculate the hash correctly" 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,
+        _next: null,
+        _id: "hello",
+        entries: [
+          {_id: "hello2", _sig: "nohteunth"},
+        ]
+      }
+
+      vm_rehash_page(page);
+    }
+
+    #Calculate hash ourselves
+    hash = crc32("hello")
+    hash = crc32("nohteunth", 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,
+      "_id" => "hello",
+      "entries" => [
+        {"_id" => "hello2", "_sig" => "nohteunth"}
+      ],
+      "_hash" => hash.to_s
+    })
+  end
+
+  it "vm_rehash_page can calculate the hash correctly with head and next" 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: "a",
+        _next: "b",
+        _id: "hello",
+        entries: [
+          {_id: "hello2", _sig: "nohteunth"},
+        ]
+      }
+
+      vm_rehash_page(page);
+    }
+
+    #Calculate hash ourselves
+    hash = crc32("a")
+    hash = crc32("b", hash)
+    hash = crc32("hello", hash)
+    hash = crc32("nohteunth", hash)
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    #Expect the same hash
+    expect(page).to eq({
+      "_head" => "a",
+      "_next" => "b",
+      "_id" => "hello",
+      "entries" => [
+        {"_id" => "hello2", "_sig" => "nohteunth"}
+      ],
+      "_hash" => hash.to_s
+    })
+  end
+
+  it "Can call vm_cache_write and save it to vm_cache[ns][id]" 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
+      page = {
+        _head: "a",
+        _next: "b",
+        _id: "hello",
+        entries: [
+          {_id: "hello2", _sig: "nohteunth"},
+        ]
+      }
+
+      vm_rehash_page(page);
+
+      //Save page
+      vm_cache_write("user", page);
+    }
+
+    vm_cache = JSON.parse(ctx.eval("JSON.stringify(vm_cache)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"));
+
+    #Expect the same hash
+    expect(vm_cache).to eq({
+      "user" => {
+        page["_id"] => page
+      }
+    })
+  end
+
+  it "Can create a copy of pg_spec0 and receive the correct things in it's initialization" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller0.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+    ctx.eval %{
       base = _embed("my_controller", 0, {}, null);
 
       //Drain queue
       int_dispatch([]);
     }
 
-    #Trigger notification
-    ctx.eval("spec2_spec_trigger()")
+    pg_spec0_init_params = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_init_params)"))
+
+    #Expect options and ns to match in config4
+    expect(pg_spec0_init_params).to eq({
+      "ns" => "spec",
+      "options" => {"hello" => "world"}
+    })
+  end
+
+  it "Does call pagers watch function with a undefined page when no page exists in cache" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller7.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #We are watching a page that should have been stored in cache at this point
+    pg_spec0_watchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_watchlist)"))
+
+    #Expect options and ns to match in config4
+    expect(pg_spec0_watchlist).to eq([{
+      "id" => "my_key"
+    }])
+  end
+
+  it "Does call pagers watch function with a page when the page requested for a watch is stored in cache" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller7.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    #We are going to manually store a page in cache as this page should be retrieved
+    #for the watch attempt
+    res = ctx.eval %{
+      //Manually construct a page as we are going to test the watch function
+      //which receives a call to watch with the hash of this page so the 
+      //watch function can tell if the page has changed (e.g. if you are connecting)
+      //to a remote server
+      page = {
+        _head: "a",
+        _next: "b",
+        _id: "my_key",
+        entries: [
+          {_id: "hello2", _sig: "nohteunth"},
+        ]
+      }
+
+      vm_rehash_page(page);
+
+      //Save page for the spec pager
+      vm_cache_write("spec", page);
+    }
+
+    #This hash was calculated during vm_rehash_page
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #We are watching a page that should have been stored in cache at this point
+    pg_spec0_watchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_watchlist)"))
+
+    #Expect options and ns to match in config4
+    expect(pg_spec0_watchlist).to eq([{
+      "id" => "my_key",
+      "page" => page
+    }])
+  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") 
+
+    expect {
+      ctx.eval %{
+        base = _embed("my_controller", 1, {}, null);
+
+        //Drain queue
+        int_dispatch([]);
+      }
+    }.to raise_exception
+  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") 
+
+    expect {
+      ctx.eval %{
+        base = _embed("my_controller", 1, {}, null);
+
+        //Drain queue
+        int_dispatch([]);
+      }
+    }.to raise_exception
+  end
+
+  it "multiple sequential watch requests from two controllers for a namespace do not hit the pager multiple times" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+      base2 = _embed("my_controller", base+2, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #We are watching a page that should have been stored in cache at this point
+    pg_spec0_watchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_watchlist)"))
+
+    #Expect options and ns to match in config4
+    expect(pg_spec0_watchlist).to eq([{
+      "id" => "my_key"
+    }])
+  end
+
+  it "unwatch request to pager does call the pagers unwatch function" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller9.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #We are watching a page that should have been stored in cache at this point
+    pg_spec0_unwatchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_unwatchlist)"))
+
+    expect(pg_spec0_unwatchlist).to eq(["my_key"])
+  end
+
+  it "watch unwatch and watch request for a namespace does hit the pager multiple times" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller9.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #We are watching a page that should have been stored in cache at this point
+    pg_spec0_watchlist = JSON.parse(ctx.eval("JSON.stringify(pg_spec0_watchlist)"))
+
+    #Expect options and ns to match in config4
+    expect(pg_spec0_watchlist).to eq([{
+      "id" => "my_key"
+    }, {
+      "id" => "my_key"
+    }])
+  end
+
+  it "sends write requests to the pager" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller10.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Expect the page to be written to cache
+    vm_cache = JSON.parse(ctx.eval("JSON.stringify(vm_cache)"));
+    vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list[0])"));
+    expect(vm_cache["spec"]["test"]).to eq(vm_write_list)
+  end
+
+  it "sends watch callback to controller when cache is written to via read_res" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller11.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list[0])"));
+    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
+    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([]);
+    }
+
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list)"));
+    expect(read_res_params).to eq(vm_write_list)
+  end
+
+  it "vm_cache_write does not tell controllers an update has occurred if the page requested to cache was already cached" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller13.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    read_res_params = JSON.parse(ctx.eval("JSON.stringify(read_res_params)"))
+    vm_write_list = JSON.parse(ctx.eval("JSON.stringify(vm_write_list)"));
+    expect(read_res_params).to eq([vm_write_list[0]])
+  end
+
+  it "updates vm_notify_map when a watch takes place" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller14.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    base = ctx.eval("base")
+    vm_notify_map = JSON.parse(ctx.eval("JSON.stringify(vm_notify_map)"));
+    expect(vm_notify_map).to eq({
+      "spec" => {
+        "test" => [base]
+      }
+    })
+  end
+
+  it "updates vm_bp_to_nmap when a watch takes place" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller14.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    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({
+      base.to_s => {
+        "spec" => {
+          "test" => [[3], 0]
+        }
+      }
+    })
+
+    #Removing the element from the given pointer in vm_bp_to_nmap to the array will also alter vm_notify_map's array
+    #if it is a reference
+    ctx.eval %{ 
+      //Grab the array that contains [node, index] where node is a reference to an array of vm_notify_map[ns][key]
+      var e = vm_bp_to_nmap[base]["spec"]["test"];
+      var node = e[0];
+      var index = e[1];
+
+      //Remove an element from the node
+      node.splice(index, 1);
+    }
+
+    vm_notify_map_after = JSON.parse(ctx.eval("JSON.stringify(vm_notify_map)"))
+    expect(vm_notify_map_after).to eq({
+      "spec" => {
+        "test" => []
+      }
+    })
+  end
 
-    #read_res from spec is called multiple times and returns an array of the parms
-    res = JSON.parse(ctx.eval("JSON.stringify(read_res_called_with)"))
+  it "updates vm_notify_map when an unwatch takes place" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller15.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
 
-    #Expect 2 responses, first is cache miss, second is cache hit, third is cache updated
-    expect(res).to eq [
-      {"key" => "my_key", "value" => "a"},
-      {"key" => "my_key", "value" => "a"},
-      {"key" => "my_key", "value" => "b"}
-    ]
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    base = ctx.eval("base")
+    vm_notify_map = JSON.parse(ctx.eval("JSON.stringify(vm_notify_map)"));
+    expect(vm_notify_map).to eq({
+      "spec" => {
+        "test" => []
+      }
+    })
   end
 
+  it "updates vm_bp_to_nmap when an unwatch takes place" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller15.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    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({
+      base.to_s => {
+        "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") 
+
+    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" => {
+        "test" => []
+      }
+    })
+  end
+
+  it "Erases entries in vm_bp_to_nmap and vm_notify_map for a controller that disconnects with two controllers maintaining correct" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller16.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" => {
+        "test" => []
+      }
+    })
+  end
+
+  it "Stores dirty pages written via vm_cache_write in vm_dirty" 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
+      page = {
+        _head: "a",
+        _next: "b",
+        _id: "hello",
+        entries: [
+          {_id: "hello2", _sig: "nohteunth"},
+        ]
+      }
+
+      vm_rehash_page(page);
+
+      //Save page
+      vm_cache_write("user", page);
+    }
+
+    vm_dirty = JSON.parse(ctx.eval("JSON.stringify(vm_dirty)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"));
+
+    #Expect the same hash
+    expect(vm_dirty).to eq({
+      "user" => {
+        page["_id"] => page
+      }
+    })
+  end
+
+  it "Tries to write to disk when the pageout runs" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller18.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Call pageout *now*
+      vm_pageout();
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    @driver.ignore_up_to "if_per_set", 0
+    @driver.mexpect("if_per_set", ["spec", page["_id"], page])
+  end
+
+  it "Does send a read request from disk cache when watching a key for the first time" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller19.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Call pageout *now*
+      vm_pageout();
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.mexpect("if_per_get", ["vm", "spec", "test"], 2)
+  end
+
+  it "Does send a sync read request from disk cache when watching a key for the first time with sync: true" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller19b.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Call pageout *now*
+      vm_pageout();
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.ignore_up_to "if_per_get", 0
+    @driver.mexpect("if_per_get", ["vm", "spec", "test"], 0)
+  end
+
+  it "Only sends one disk read request when multiple non-sync watches are attempted" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+      base2 = _embed("my_controller", base+2, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.get "if_per_get", 2
+
+    #There should not be another request for the drive
+    expect {
+      @driver.ignore_up_to "if_per_get"
+    }.to raise_exception
+  end
+
+  it "Only sends one disk read request when multiple watches are attempted, and the first watch is sync: true" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller_sync", 1, {}, null);
+      base2 = _embed("my_controller", base+2, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.ignore_up_to "if_per_get", 0
+    @driver.get "if_per_get", 0
+
+    #There should not be another request for the drive
+    expect {
+      @driver.ignore_up_to "if_per_get"
+    }.to raise_exception
+  end
+
+  it "Sends two disk read request when multiple watches are attempted, and the second watch is sync: true but the disk does not read back before it is requested" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+      base2 = _embed("my_controller_sync", base+2, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #The inner controller's on_entry is called before, so it's in reverse order
+    @driver.ignore_up_to "if_per_get", 0
+    @driver.get "if_per_get", 0
+    @driver.ignore_up_to "if_per_get", 2
+  end
+
+  it "Sends one disk read request when multiple watches are attempted, and the second watch is sync: true and the disk *does* read back before it is requested" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb");
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page0 = JSON.parse(ctx.eval("JSON.stringify(page0)"))
+    @driver.int "int_per_get_res", ["vm", "spec", page0]
+
+    ctx.eval %{
+      base2 = _embed("my_controller_sync", base+2, {}, null);
+    }
+
+    #The inner controller's on_entry is called before, so it's in reverse order
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.get "if_per_get", 2
+
+    #There should not be another request for the drive
+    expect {
+      @driver.ignore_up_to "if_per_get"
+    }.to raise_exception
+  end
+
+  it "Only sends one disk read request when multiple sync watches are attempted" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller8.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller_sync", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.ignore_up_to "if_per_get", 0
+    @driver.get "if_per_get", 0
+
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    @driver.int "int_per_get_res", ["vm", "spec", page]
+
+    ctx.eval %{
+      base2 = _embed("my_controller_sync", base+2, {}, null);
+    }
+
+    #There should not be another request for the drive
+    expect {
+      @driver.ignore_up_to "if_per_get"
+    }.to raise_exception
+  end
+
+
+  it "Clears the dirty page when pageout runs" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller18.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", {}]);
+    }
+
+    ctx.eval("vm_pageout()");
+
+    vm_dirty = JSON.parse(ctx.eval("JSON.stringify(vm_dirty)"))
+    expect(vm_dirty).to eq({
+      "spec" => {}
+    })
+  end
+
+  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" 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
+
+    #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([
+      page2
+    ])
+  end
+
+  it "Does within 21 seconds of a write on bootup, write to disk" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller18.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    (4*21).times do
+      @driver.int "int_timer", []
+    end
+
+    @driver.ignore_up_to "if_per_set", 0
+    @driver.mexpect("if_per_set", ["spec", page["_id"], page])
+  end
+
+  it "Does not attempt to write twice to disk after 41 seconds if there is no pending data to write" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller21.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    (4*41).times do
+      @driver.int "int_timer", []
+    end
+
+    @driver.ignore_up_to "if_per_set", 0
+    @driver.mexpect("if_per_set", ["spec", page["_id"], page])
+
+    expect {
+      @driver.ignore_up_to "if_per_set"
+    }.to raise_exception
+  end
+
+  it "Does attempt to write twice to disk after 41 seconds if there is pending data to write" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller21.rb'), File.read("./spec/kern/assets/vm/config4.rb") 
+
+    ctx.eval %{
+      base = _embed("my_controller", 1, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    base = ctx.eval("base")
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    (4*21).times do
+      @driver.int "int_timer", []
+    end
+
+    @driver.ignore_up_to "if_per_set", 0
+    @driver.mexpect("if_per_set", ["spec", page["_id"], page])
+
+    #Call next on controller which will write an new page
+    ctx.eval %{ int_dispatch([3, "int_event", base, "next", {}]); }
+
+    page2 = JSON.parse(ctx.eval("JSON.stringify(page2)"))
+    (4*21).times do
+      @driver.int "int_timer", []
+    end
+
+    @driver.ignore_up_to "if_per_set", 0
+    @driver.mexpect("if_per_set", ["spec", page2["_id"], page2])
+ end
 end