flok 0.0.102 → 0.0.103

data/spec/iface/driver/dispatch_spec.rb

@@ -20,6 +20,13 @@ RSpec.describe "iface:driver:dispatch_spec" do
     expect(@pipe).not_to readline_and_equal_json_x_within_y_seconds([], 6.seconds)
   end
 
+  it "Does automatically dispatch a blank array (signaling int_disptach) when a blank queue is received prefixed with 'i' indicating incomplete-ness but after the queue is processed if it has entries" do
+    @pipe.puts ['i', [0, 0, "ping"]].to_json
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "pong"], 10.seconds)
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([], 6.seconds)
+  end
+
+
   #While at first you might think we need to test that int_dispatch called intra-respond of our if_event needs to test whether or not we still send
   #out blank [] to int_dispatch; this is not the case. In the real world, flok is supposed to also make any necessary if_disptach calls during all
   #int_dispatch calls. We would always receive back if_dispatch; and thus it would follow the same rules as layed out here

data/spec/iface/driver/hook_spec.rb

@@ -8,26 +8,102 @@ RSpec.describe "iface:driver:hook" do
   module_dep "hook"
   include_context "iface:driver"
 
-  it "Can receive a hook event request with parameters" do
+  it "Can receive a single hook event request with parameters and respond with the test handler" do
     @ptr = SecureRandom.hex
 
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
     #Simulate a hook event on the main queue
-    @pipe.puts [[0, 3, "if_hook_event", "test", {foo: "bar"}]].to_json
+    @pipe.puts [[0, 2, "if_hook_event", "test", {foo: "bar"}]].to_json
+
+    json = [
+      1,
+      "hook_dump_res",
+      {
+        "name" => "test",
+        "info" => {"foo" => "bar"}
+      }
+    ]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+  end
+
+  it "Can receive two hook event requests with parameters and respond with the test handler twice" do
+    @ptr = SecureRandom.hex
 
     #Wait for response
     @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
 
-    #Get the value of the received event
-    @pipe.puts [[0, 1, "if_hook_spec_dump_rcvd_events"]].to_json
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 2, "if_hook_event", "test", {foo: "bar"}]].to_json
 
     json = [
       1,
-      "if_hook_spec_dump_rcvd_events_res",
-      [{
+      "hook_dump_res",
+      {
         "name" => "test",
         "info" => {"foo" => "bar"}
-      }]
+      }
     ]
     expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 2, "if_hook_event", "test", {foo: "bar2"}]].to_json
+
+    json = [
+      1,
+      "hook_dump_res",
+      {
+        "name" => "test",
+        "info" => {"foo" => "bar2"}
+      }
+    ]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+  end
+
+  it "Can receive two hook event requests with parameters and respond with the test and test2 handler" do
+    @ptr = SecureRandom.hex
+
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 2, "if_hook_event", "test", {foo: "bar"}]].to_json
+
+    json = [
+      1,
+      "hook_dump_res",
+      {
+        "name" => "test",
+        "info" => {"foo" => "bar"}
+      }
+    ]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 2, "if_hook_event", "test2", {foo: "bar2"}]].to_json
+
+    json = [
+      1,
+      "hook_dump_res",
+      {
+        "name" => "test2",
+        "info" => {"foo" => "bar2"}
+      }
+    ]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+  end
+
+  it "Can receive a hook without a handler and not crash" do
+    @ptr = SecureRandom.hex
+
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 2, "if_hook_event", "test3", {foo: "bar"}]].to_json
+
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
   end
 end

data/spec/iface/driver/net_spec.rb

@@ -9,63 +9,72 @@ RSpec.describe "iface:driver:net" do
   include_context "iface:driver"
 
   it "Can call a network request" do
-    web = Webbing.get "/" do
-      @hit = true
-      {}
-    end
+    begin
+      web = Webbing.get "/" do
+        @hit = true
+        {}
+      end
 
-    @ptr = SecureRandom.hex
-    @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {}, @ptr]].to_json
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 4, "if_net_req","GET", "http://127.0.0.1:#{web.port}", {}, @ptr]].to_json
 
-    #Wait for response
-    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
 
-    expect(@hit).to eq(true)
+      #Wait for response
+      @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+      sleep 1
 
-    web.kill
+      expect(@hit).to eq(true)
+    ensure
+      web.kill
+    end
   end
 
   it "Can call a network request with parameters" do
-    @secret = SecureRandom.hex
-    web = Webbing.get "/" do |params|
-      @rcv_secret = params['secret']
-      {}
+    begin
+      @secret = SecureRandom.hex
+      web = Webbing.get "/" do |params|
+        @rcv_secret = params['secret']
+        {}
+      end
+
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
+
+      #Wait for response
+      @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+      sleep 1
+
+      expect(@rcv_secret).to eq(@secret)
+    ensure
+      web.kill
     end
-
-    @ptr = SecureRandom.hex
-    @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
-
-    #Wait for response
-    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
-
-    expect(@rcv_secret).to eq(@secret)
-
-    web.kill
   end
 
   it "Does send a network interupt int_net_cb with success and the correct payload" do
-    @secret = SecureRandom.hex
-    @secret2 = SecureRandom.hex
-    @secret2msg = {"secret2" => @secret2}
-    web = Webbing.get "/" do |params|
-      @rcv_secret = params['secret']
-
-      @secret2msg
+    begin
+      @secret = SecureRandom.hex
+      @secret2 = SecureRandom.hex
+      @secret2msg = {"secret2" => @secret2}
+      web = Webbing.get "/" do |params|
+        @rcv_secret = params['secret']
+
+        @secret2msg
+      end
+
+      #Wait for response
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
+
+      res = [3, "int_net_cb", @ptr, true, @secret2msg]
+      expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+    ensure
+      web.kill
     end
-
-    #Wait for response
-    @ptr = SecureRandom.hex
-    @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
-
-    res = [3, "int_net_cb", @ptr, true, @secret2msg]
-    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
-
-    web.kill
   end
 
   it "Does send a network interupt int_net_cb with error and the correct payload" do
     #Wait for response
-    @ptr = SecureRandom.hex
+      @ptr = rand(9999999)
     @pipe.puts [[1, 4, "if_net_req", "GET", "http://no_such_url#{SecureRandom.hex}.com", {}, @ptr]].to_json
 
     matcher = proc do |x|

data/spec/iface/driver/persist_spec.rb

@@ -8,8 +8,13 @@ RSpec.describe "iface:driver:persist" do
   module_dep "persist"
   include_context "iface:driver"
 
+  before(:each) do
+    hard_restart_driver
+  end
+
  it "Can receive persist API messages without crashing" do
     #Disk is scheduling class 2
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
     @pipe.puts [[2, 3, "if_per_set", "my_ns", "my_key", "my_value"]].to_json
     @pipe.puts [[2, 3, "if_per_get", "session", "my_ns", "my_key"]].to_json
     @pipe.puts [[2, 2, "if_per_del", "my_ns", "my_key"]].to_json
@@ -17,9 +22,6 @@ RSpec.describe "iface:driver:persist" do
 
     #These are from the get requests
     @pipe.readline_timeout
-
-    @pipe.puts [[0, 0, "ping"]].to_json; 
-    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "pong"], 8.seconds)
   end
 
  it "retuns null when calling get on a blank key" do
@@ -34,11 +36,29 @@ RSpec.describe "iface:driver:persist" do
   end
 
   it "Can set a persist, and then get" do
-    key = SecureRandom.hex
+    key = "persist_key"
     value = SecureRandom.hex
 
     #Disk is scheduling class 2
     @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
+    sleep 3
+    restart_driver_but_persist
+    @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response
+    res = [4, "int_per_get_res", "session", "my_ns", key, value]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 8.seconds)
+  end
+
+  it "Can set a persist for a dictionary object, and then get" do
+    key = "persist_key"
+    value = {"foo" => "bar"}
+
+    #Disk is scheduling class 2
+    @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
+    sleep 3
     restart_driver_but_persist
     @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
 
@@ -47,6 +67,24 @@ RSpec.describe "iface:driver:persist" do
     expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 8.seconds)
   end
 
+
+  #Not the bests of tests, but it's really testing the ability of the pipe
+  #interface to properly reset the device's data
+  it "Does not persists between tests (i.e. not restarts but complete new tests)" do
+    key = "persist_key"
+    value = SecureRandom.hex
+
+    #Disk is scheduling class 2
+    @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
+    hard_restart_driver
+    @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response (with nil)
+    res = [4, "int_per_get_res", "session", "my_ns", key, nil]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 8.seconds)
+  end
+
   it "Can set a persist, delete the key, and then get" do
     key = SecureRandom.hex
     value = SecureRandom.hex
@@ -54,6 +92,8 @@ RSpec.describe "iface:driver:persist" do
     #Disk is scheduling class 2
     @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
     @pipe.puts [[2, 2, "if_per_del", "my_ns", key]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
+    sleep 2
     restart_driver_but_persist
     @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
 
@@ -72,6 +112,7 @@ RSpec.describe "iface:driver:persist" do
     @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
     @pipe.puts [[2, 3, "if_per_set", "my_ns", key2, value2]].to_json
     @pipe.puts [[2, 2, "if_per_del", "my_ns", key]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
     restart_driver_but_persist
     @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
     @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key2]].to_json
@@ -92,6 +133,8 @@ RSpec.describe "iface:driver:persist" do
     #Disk is scheduling class 2
     @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
     @pipe.puts [[2, 1, "if_per_del_ns", "my_ns"]].to_json
+    @pipe.puts [[2, 0, "ping"]].to_json; @pipe.readline_timeout
+    sleep 2
     restart_driver_but_persist
     @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
 

data/spec/iface/driver/ping_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe "iface:driver:ping_spec" do
 
   it "supports ping" do
     @pipe.puts [[0, 0, "ping"]].to_json
-    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "pong"], 6.seconds)
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "pong"], 10.seconds)
   end
 
   it "supports ping1" do

data/spec/iface/driver/rtc_spec.rb

@@ -12,10 +12,10 @@ RSpec.describe "iface:driver:rtc" do
     #Wait for response
     @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
 
-    @pipe.puts [[0, 1, "if_rtc_init"]].to_json
+    @pipe.puts [[0, 0, "if_rtc_init"]].to_json
 
     #Wait to start until after the 1st event fires to make sure timer started up
-    @pipe.readline
+    @pipe.readline_timeout
     expect(@pipe).to readline_and_equal_json_x_within_y_seconds([1, "int_rtc", Fixnum], 5.seconds)
     start_time = Time.now.to_i
     5.times do

data/spec/iface/driver/sockio_spec.rb

@@ -10,8 +10,8 @@ RSpec.describe "iface:driver:sockio_spec" do
 
   it "does allow calling of sockio functions" do
     @pipe.puts [[0, 2, "if_sockio_init", "test", 0]].to_json
-    @pipe.puts [[0, 3, "if_sockio_fwd", "hello", "test", 0]].to_json
-    @pipe.puts [[0, 3, "if_sockio_send", "hello", {}]].to_json
+    @pipe.puts [[0, 3, "if_sockio_fwd", 11, "test", 0]].to_json
+    @pipe.puts [[0, 3, "if_sockio_send", 11, "hello", {}]].to_json
 
     #Wait for response
     @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
@@ -40,7 +40,8 @@ RSpec.describe "iface:driver:sockio_spec" do
     #Start up the node server and wait for a CLIENT CONNECTED response
     sh2 "node", "./spec/iface/driver/assets/sockio_server.js", /STARTED/ do |server_in, server_out|
       #Start forwarding information to base pointer 0
-      @pipe.puts [[0, 2, "if_sockio_init", "http://localhost:9998", 0, 3, "if_sockio_send", 0, "test", {"hello" => "world"}]].to_json
+      @pipe.puts [[0, 2, "if_sockio_init", "http://localhost:9998", 0]].to_json
+      @pipe.puts [[0, 3, "if_sockio_send", 0, "test", {"hello" => "world"}]].to_json
 
       #Expect the server to get a client connection
       expect(server_out).to readline_and_equal_x_within_y_seconds("CLIENT CONNECTED", 10.seconds)

data/spec/iface/driver/timer_spec.rb

@@ -36,4 +36,24 @@ RSpec.describe "iface:driver:timer" do
     expect(end_time - start_time).to be < 10 
     expect(end_time - start_time).to be > 5
   end
+
+  it "Does support a different ticks-per-second interval" do
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
+    #This time, 60 ticks per second
+    @pipe.puts [[3, 1, "if_timer_init", 60]].to_json
+
+    #Wait to start until after the 1st event fires to make sure timer started up
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "int_timer"], 5.seconds)
+    start_time = Time.now.to_i
+    300.times do
+      expect(@pipe).to readline_and_equal_json_x_within_y_seconds([0, "int_timer"], 2.seconds)
+    end
+    end_time = Time.now.to_i
+
+    #Just leave some room for connection latency, etc.
+    expect(end_time - start_time).to be < 7
+    expect(end_time - start_time).to be > 2
+  end
 end

data/spec/iface/driver/ui_spec.rb

@@ -5,7 +5,7 @@ require './spec/lib/helpers.rb'
 require './spec/lib/io_extensions.rb'
 require './spec/lib/rspec_extensions.rb'
 
-RSpec.describe "iface:driver:net" do
+RSpec.describe "iface:driver:ui" do
   module_dep "ui"
   include_context "iface:driver"
 
@@ -14,14 +14,14 @@ RSpec.describe "iface:driver:net" do
     @pipe.puts [[0, 0, "if_ui_spec_init"]].to_json
   end
 
-it "Can create and embed views into the root hierarchy" do
+  it "Can create and embed views into the root hierarchy" do
     #Create a new view 'spec'
     @pipe.puts [[0, 4, "if_init_view", "spec_blank", {}, 333, ["main"]]].to_json
 
     #Attach that view to the root
     @pipe.puts [[0, 2, "if_attach_view", 333, 0]].to_json
 
-    #Request a listing of all the views on the root node
+j   #Request a listing of all the views on the root node
     @pipe.puts [[0, 1, "if_ui_spec_views_at_spot", 0]].to_json
     expect(@pipe).to readline_and_equal_json_x_within_y_seconds([1, "spec", 333], 6.seconds)
   end
@@ -134,7 +134,7 @@ it "Can create and embed views into the root hierarchy" do
     @pipe.puts [[0, 4, "if_init_view", "spec_blank", {}, 335, ["main"]]].to_json
 
     #Attach the child to the parent view (it should be destoryed with the parent)
-    @pipe.puts [[0, 2, "if_attach_view", 335, 333]].to_json
+    @pipe.puts [[0, 2, "if_attach_view", 335, 334]].to_json
     @pipe.puts [[0, 2, "if_attach_view", 333, 0]].to_json
 
     #Views should exists
@@ -155,3 +155,26 @@ it "Can create and embed views into the root hierarchy" do
     expect(@pipe).to readline_and_equal_json_x_within_y_seconds([1, "spec", false], 6.seconds)
   end
 end
+
+#These are optional specs that may not necessarily match the implementation semantics. These
+#'typical' semantics include loading the context in a 'views' 'initializer' portion, etc.
+#RSpec.describe "iface:driver:ui:typical_extra" do
+  #module_dep_defines name:"ui", defines: "ui_typical_extra_specs"
+  #include_context "iface:driver"
+
+  #before(:each) do
+    ##Initialize
+    #@pipe.puts [[0, 0, "if_ui_spec_init"]].to_json
+  #end
+
+  ##it "Does receive the context in the view initializer" do
+    ###Create a new view 'spec'
+    ##@pipe.puts [[0, 4, "if_init_view", "spec_blank_sends_context", {}, 333, ["main"]]].to_json
+
+    ###Attach that view to the root
+    ##@pipe.puts [[0, 2, "if_attach_view", 333, 0]].to_json
+
+##j   #Request a listing of all the views on the root node
+    ##expect(@pipe).to readline_and_equal_json_x_within_y_seconds([3, "int_event", 333, "context", {"foo" => "bar"}], 6.seconds)
+  ##end
+#end