flok 0.0.36 → 0.0.38

data/spec/etc/lib/assets/config.yml

@@ -0,0 +1,3 @@
+DEBUG:
+  mods:
+    - hello

data/spec/etc/lib/platform_spec.rb

@@ -1,5 +1,6 @@
 Dir.chdir File.join File.dirname(__FILE__), '../../../'
 require './lib/flok'
+require './spec/lib/temp_dir'
 
 #We are using the CHROME module as a test because it's fairly standardized
 
@@ -11,23 +12,26 @@ RSpec.describe "lib/platform" do
     expect(platforms).to include("chrome")
   end
 
-  it "can list platform specific config_yml" do
-    debug_yml = Flok::Platform.config_yml("chrome", "DEBUG")
-    release_yml = Flok::Platform.config_yml("chrome", "RELEASE")
+  it "can list specific config_yml" do
+    debug_yml = Flok::Platform.config_yml("DEBUG")
+    release_yml = Flok::Platform.config_yml("RELEASE")
 
-    expect(debug_yml.keys).not_to eq(0)
+    expect(debug_yml.keys.count).not_to eq(0)
 
     #Should not have same modules (at least for chrome)
     expect(release_yml["mods"].count).not_to eq(release_yml.keys.count)
   end
 
-  it "can list modules specific to a platform and environment" do
-    debug_mods = Flok::Platform.mods("chrome", "DEBUG")
-    release_mods = Flok::Platform.mods("chrome", "RELEASE")
+  it "can list modules specific to an environment" do
+    config_yml = File.read("./spec/etc/lib/assets/config.yml")
+    Dir.chdir new_temp_dir do
+      File.write "config.yml", config_yml
+      ENV['FLOK_CONFIG'] = './config.yml'
 
-    expect(debug_mods.count).not_to eq(0)
+      debug_mods = Flok::Platform.mods("DEBUG")
 
-    #Should not have same modules (at least for chrome) in debug and release
-    expect(debug_mods.count).not_to eq(release_mods.count)
+      expect(debug_mods).to include("hello")
+      ENV['FLOK_CONFIG'] = nil
+    end
   end
 end

data/spec/etc/lib/project_spec.rb

@@ -22,4 +22,26 @@ RSpec.describe "lib/project" do
       end
     end
   end
+
+  it "Does contain a copy of the config.yml for the currently active platform in ./config/platforms/$PLATFORM/config.yml" do
+    platform = ENV['PLATFORM']
+
+    dir = new_temp_dir
+    Dir.chdir dir do
+      Flok::Project.create "test"
+      Dir.chdir "test" do
+        #Directory ./config/platforms/$PLATFORM should exist
+        expect(dirs).to include("config/platforms/#{platform}")
+        
+        #File ./config/platforms/$PLATFORM/config.yml should exist
+        Dir.chdir "./config/platforms/#{platform}" do
+          expect(files).to include("config.yml")
+        end
+
+        #Files should match in config
+        platform_config_path = File.join(File.dirname(__FILE__), "../../../app/drivers/#{platform}/config.yml")
+        expect(File.read("./config/platforms/#{platform}/config.yml").strip).to eq(File.read(platform_config_path).strip)
+      end
+    end
+  end
 end

data/spec/etc/service_compiler/config0.rb

@@ -0,0 +1 @@
+service_instance :test, :my_service

data/spec/etc/service_compiler/config1.rb

@@ -0,0 +1 @@
+service_instance :blah, :my_service

data/spec/etc/service_compiler/config2.rb

@@ -0,0 +1,3 @@
+service_instance :test, :my_service, {
+  hello: "23rntoheuh3nthoeunthn23th"
+}

data/spec/etc/service_compiler/service0.rb

@@ -1,10 +1,26 @@
-service("test") do
-  on_init %{
-    test_service_var = true;
+service :my_service do
+  on_wakeup %{
+    on_wakeup_called = true;
   }
 
-  on_request %{
-    //Services should allow for info, ep, and name
-    test_service_request = [info, ep, ename]
+  on_sleep %{
+    on_sleep_called = true;
+  }
+
+  on_connect %{
+    on_connect_called_bp = bp;
+  }
+
+  on_disconnect %{
+    on_disconnect_called_bp = bp;
+  }
+
+  on "hello", %{
+    on_hello_called_bp = bp;
+    on_hello_called_params = JSON.stringify(params);
+  }
+
+  every 5.seconds, %{
+    on_every_5_sec_called = true;
   }
 end

data/spec/etc/service_compiler/service1.rb

@@ -0,0 +1,26 @@
+service :my_service do
+  on_wakeup %{
+    on_wakeup_called = '#{@options[:hello]}';
+  }
+
+  on_sleep %{
+    on_sleep_called = true;
+  }
+
+  on_connect %{
+    on_connect_called_bp = bp;
+  }
+
+  on_disconnect %{
+    on_disconnect_called_bp = bp;
+  }
+
+  on "hello", %{
+    on_hello_called_bp = bp;
+    on_hello_called_params = JSON.stringify(params);
+  }
+
+  every 5.seconds, %{
+    on_every_5_sec_called = true;
+  }
+end

data/spec/etc/service_compiler/service_bad_type.rb

@@ -0,0 +1,20 @@
+service :test do
+  on_wakeup %{
+    test_service_var = true;
+  }
+
+  on_sleep %{
+  }
+
+  on_connect %{
+  }
+
+  on_disconnect %{
+  }
+
+  on_event "hello", %{
+  }
+
+  every 5.seconds, %{
+  }
+end

data/spec/etc/services_compiler_spec.rb

@@ -4,13 +4,14 @@ require './spec/env/etc'
 
 RSpec.describe "lib/services_compiler" do
   #Return a v8 instance of a compiled js file
-  def compile fn
+  def compile fn, config
     compiler = Flok::ServicesCompiler
     js_src(fn)
-    js_res = compiler.compile(js_src(fn))
+    js_res = compiler.compile(js_src(fn), js_src(config))
     ctx = V8::Context.new
     ctx.eval js_res
-    ctx
+
+    return ctx, js_res
   end
 
   #Get the source for a file in  ./service_compiler/*.rb
@@ -20,22 +21,40 @@ RSpec.describe "lib/services_compiler" do
     end
   end
 
-  it "Can call compile method and get on_init" do
-    ctx = compile "service0"
-
-    #The service defines a variable in on_init, this should be always accessible
-    res = ctx.eval("test_service_var")
-    expect(res).to eq(true)
+  it "Does fail to compile a controller with a non-existant type" do
+    expect { compile "service_bad_type" }.to raise_exception
   end
 
-  it "Can call compile method and get on_request" do
-    ctx = compile "service0"
+  it "Can call compile method and get a copy of all the functions" do
+     ctx, _  = compile "service0", "config0"
+
+    #on_wakeup
+    res = ctx.eval("test_on_wakeup")
+    expect(res).not_to eq(nil)
+
+    #on_sleep
+    res = ctx.eval("test_on_sleep")
+    expect(res).not_to eq(nil)
 
-    #Should be able to call on_request generated request function
-    ctx.eval('service_test_req({}, 0, "test")')
+    #on_connect
+    res = ctx.eval("test_on_connect");
+    expect(res).not_to eq(nil)
+
+    #on_disconnect
+    res = ctx.eval("test_on_disconnect")
+    expect(res).not_to eq(nil)
+
+    #on_event
+    res = ctx.eval("test_on_hello");
+    expect(res).not_to eq(nil)
+
+    #on_handle_timer_events
+    res = ctx.eval("test_handle_timer_events");
+    expect(res).not_to eq(nil)
+  end
 
-    #That should have set a variable
-    res = JSON.parse(ctx.eval("JSON.stringify(test_service_request)"))
-    expect(res).to eq([{}, 0, "test"])
+  it "Can call compile method with options" do
+    ctx, js = compile "service1", "config2"
+    expect(js).to include("23rntoheuh3nthoeunthn23th");
   end
 end

data/spec/etc/user_compiler/data.js

@@ -0,0 +1,2 @@
+//Test for merging in ./app/helpers/*.js folder for projects
+data = {}

data/spec/etc/user_compiler_spec.rb

@@ -40,6 +40,13 @@ RSpec.describe "User compiler" do
     expect(actions).to eq(1)
   end
 
+  it "Can compile a controller and contain an __init__ function" do
+    ctx = compile "controller0"
+    actions = ctx.eval "ctable.my_controller.__init__"
+    expect(actions).not_to eq(nil)
+  end
+
+
   it "Can compile a controller with an action that contains an on_entry" do
     ctx = compile "controller0"
     on_entry = ctx.eval "ctable.my_controller.actions.my_action.on_entry"
@@ -52,7 +59,6 @@ RSpec.describe "User compiler" do
     expect(on_entry).to eq("my_controller")
   end
 
-
   it "Can compile a controller with an action that contains an event that responds to hello" do
     ctx = compile "controller0"
     hello_event_function = ctx.eval "ctable.my_controller.actions.my_action.handlers.hello"

data/spec/iface/driver/persist_spec.rb

@@ -0,0 +1,106 @@
+Dir.chdir File.join File.dirname(__FILE__), '../../../'
+require './spec/env/iface.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+
+RSpec.describe "iface:driver:persist" do
+  module_dep "persist"
+  include_context "iface:driver"
+
+ it "Can receive persist API messages without crashing" do
+    #Disk is scheduling class 2
+    @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
+    @pipe.puts [[2, 1, "if_per_del_ns", "my_ns"]].to_json
+
+    #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"], 5.seconds)
+  end
+
+  it "Can set a persist, and then synchronously get" do
+    key = SecureRandom.hex
+    value = SecureRandom.hex
+
+    #Disk is scheduling class 2
+    @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
+    restart_driver_but_persist
+    @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response
+    res = [2, "int_per_get_res", "session", value]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+
+
+ it "Can set a persist, and then asynchronously get" do
+    key = SecureRandom.hex
+    value = SecureRandom.hex
+
+    #Disk is scheduling class 2
+    @pipe.puts [[2, 3, "if_per_set", "my_ns", key, value]].to_json
+    restart_driver_but_persist
+    @pipe.puts [[2, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response
+    res = [2, "int_per_get_res", "session", value]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+
+it "Can set a persist, delete the key, and then synchronously get" do
+    key = SecureRandom.hex
+    value = SecureRandom.hex
+
+    #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
+    restart_driver_but_persist
+    @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response
+    res = [2, "int_per_get_res", "session", nil]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+
+ it "Can set two persists, delete one key, and then synchronously get" do
+    key = SecureRandom.hex
+    key2 = SecureRandom.hex
+    value = SecureRandom.hex
+    value2 = SecureRandom.hex
+
+    #Disk is scheduling class 2
+    @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
+    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
+
+    #Results for first key
+    res = [2, "int_per_get_res", "session", nil]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+
+    #Expect a response
+    res = [2, "int_per_get_res", "session", value2]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+
+  it "Can set a persist, delete the key via ns, and then synchronously get" do
+    key = SecureRandom.hex
+    value = SecureRandom.hex
+
+    #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
+    restart_driver_but_persist
+    @pipe.puts [[0, 3, "if_per_get", "session", "my_ns", key]].to_json
+
+    #Expect a response
+    res = [2, "int_per_get_res", "session", nil]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+end

data/spec/iface/driver/pipe_spec.rb

@@ -28,4 +28,9 @@ RSpec.describe "iface:driver:pipe_spec" do
 
     expect(pid).to die_within(6.seconds)
   end
+
+  it "does have the ability to receive a RESTART command" do
+    @pipe.puts "RESTART"
+    expect(@pipe).to readline_and_equal_x_within_y_seconds("RESTART OK", 5.seconds)
+  end
 end

data/spec/iface/kern/ping_spec.rb

@@ -70,7 +70,8 @@ RSpec.describe "iface:kern:ping_spec" do
       "net" => 1,
       "disk" => 2,
       "cpu" => 3,
-      "gpu" => 4
+      "gpu" => 4,
+      "async" => 5
   }
 
  queue_name_to_index.each do |name, index|
@@ -78,7 +79,7 @@ RSpec.describe "iface:kern:ping_spec" do
       #Don't redo last one because it's part of the first term (queue_name_b)
       unless index == queue_name_to_index.count-1
         queue_name_a = name
-        queue_name_b = @last_queue_name || "gpu"
+        queue_name_b = @last_queue_name || "async"
         index_a = index
         index_b = queue_name_to_index[queue_name_b]
         @pipe.puts [1, "ping3", queue_name_a, 1, "ping3", queue_name_a, 1, "ping3", queue_name_b].to_json
@@ -104,7 +105,7 @@ RSpec.describe "iface:kern:ping_spec" do
   queue_name_to_index.each do |name, index|
     it "supports ping-over-commit" do
       #Main queue always queues all
-      if name != "main" 
+      if name != "main"  and name != "async" #main and async don't have scheduling
         @pipe.puts ([1, "ping4", name]*6).to_json
         expect(@pipe).to readline_and_equal_json_x_within_y_seconds([[index, *[0, "pong4"]*5]], 6.seconds)
         @pipe.puts ([1, "ping4", name]).to_json

data/spec/kern/assets/service0.rb

@@ -0,0 +1,24 @@
+service :my_service do
+  on_wakeup %{
+    on_wakeup_called = true; 
+  }
+
+  on_sleep %{
+    on_sleep_called = true;
+  }
+
+  on_connect %{
+    on_connect_called = true;
+  }
+
+  on_disconnect %{
+    on_disconnect_called = true;
+  }
+
+  every 1.seconds, %{
+    for (var i = 0; i < Object.keys(sessions).length; ++i) {
+      var bp = Object.keys(sessions)[i];
+      int_event(bp, "ping", {});
+    }
+  }
+end