Spider - Tests - update setup to match runtime init

Also add a new mock for the TauAPI

Author: samaaron

app/server/ruby/test/setup_test.rb

@@ -9,6 +9,48 @@
 
 module SonicPi
   class MockStudio
+
+  end
+
+  class MockTauAPI
+    def tau_ready?
+      true
+    end
+
+    def block_until_tau_ready!
+    end
+
+    def link_current_time
+      Time.now.to_i
+    end
+
+    def link_current_time_and_beat(quantise_beat=true)
+      [Time.now.to_i, 0]
+    end
+
+    def link_temp
+      120
+    end
+
+    def link_is_enabled?
+      true
+    end
+
+    def link_num_peers
+      0
+    end
+
+    def link_get_beat_at_time(time, quantum = 4)
+      0
+    end
+
+    def link_get_clock_time_at_beat(beat, quantum = 4)
+      Time.now.to_i
+    end
+
+    def link_get_beat_at_clock_time(clock_time, quantum = 4)
+      0
+    end
   end
 
   class MockLang
@@ -21,64 +63,146 @@ class MockLang
     include ActiveSupport
     def initialize
       @mod_sound_studio = MockStudio.new
-
       @msg_queue = Queue.new
       __set_default_user_thread_locals!
-
-
       @system_init_thread_id = ThreadId.new(-1)
 
-
       @settings = Config::Settings.new("/bogus/path/to/default/to/empty/settings.txt")
       @version = Version.new(0, 0, 0, "test")
       @server_version = Version.new(1, 0, 0, "final")
+
+
       @life_hooks = LifeCycleHooks.new
-      @msg_queue = Queue.new
       @cue_events = IncomingEvents.new
-      @sync_counter = Counter.new
       @job_counter = Counter.new(-1) # Start counting jobs from 0
       @job_subthreads = {}
       @job_main_threads = {}
       @named_subthreads = {}
       @job_subthread_mutex = Mutex.new
+      @osc_cue_server_mutex = Mutex.new
       @user_jobs = Jobs.new
-      @user_methods = []
       @global_start_time = Time.now
       @session_id = SecureRandom.uuid
       @snippets = {}
+      @system_state = EventHistory.new
+      @user_state = EventHistory.new
+      @event_history = EventHistory.new
+      @system_init_thread_id = ThreadId.new(-1)
       @gui_cue_log_idxs = Counter.new
-      @system_state = EventHistory.new(@job_subthreads, @job_subthread_mutex)
-      @user_state = EventHistory.new(@job_subthreads, @job_subthread_mutex)
-      @event_history = EventHistory.new(@job_subthreads, @job_subthread_mutex)
-      @system_state.set 0, 0, @system_init_thread_id, 0, 0, 60, :sched_ahead_time, 0.5
-      @register_cue_event_lambda = lambda do |t, p, i, d, b, m, address, args, sched_ahead_time=0|
+      @gui_heartbeats = {}
+      @gui_last_heartbeat = nil
 
-        address, _sym = *address if address.is_a?(Array)
+      @register_cue_event_lambda = lambda do |t, p, i, d, b, m, address, args, sched_ahead_time=0|
+        t = t.to_r
+        sym = nil
+        address, sym = *address if address.is_a?(Array)
 
         gui_log_id = @gui_cue_log_idxs.next
-        a = args.freeze
-
-        @event_history.set(t, p, i, d, b, m, address.freeze, a)
+        args = args.__sp_make_thread_safe
+        address = address.to_s.freeze
+        @event_history.set(t, p, i, d, b, m, address, args)
         @cue_events.async_event("/spider_thread_sync/#{address}", {
                                   :time => t,
-                                  :cue_splat_map_or_arr => a,
+                                  :cue_splat_map_or_arr => args,
                                   :cue => address })
 
         sched_ahead_sync_t = t + sched_ahead_time
-        sleep_time = sched_ahead_sync_t.to_f - Time.now.to_f
+
+        sleep_time = sched_ahead_sync_t - Time.now.to_r
         if sleep_time > 0
           Thread.new do
-            Kernel.sleep(sleep_time) if sleep_time > 0
-            __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => address, :args => a.inspect})
+            Kernel.sleep(sleep_time)
+            __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => address, :args => args.inspect})
+            __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => sym, :args => args.inspect}) if sym
           end
         else
-          __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => address, :args => a.inspect})
+          __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => address, :args => args.inspect})
+          __msg_queue.push({:type => :incoming, :time => t.to_s, :id => gui_log_id, :address => sym, :args => args.inspect}) if sym
+        end
+      end
+
+      external_osc_cue_handler = lambda do |time, ip, port, address, args|
+        address = "/#{address}" unless address.start_with?("/")
+        address = "/osc:#{host}:#{port}#{address}"
+        p = 0
+        d = 0
+        b = 0
+        m = 60
+        @register_cue_event_lambda.call(Time.now, p, @system_init_thread_id, d, b, m, address, args, 0)
+      end
+
+      internal_cue_handler = lambda do |path, args|
+        p = 0
+        d = 0
+        b = 0
+        m = 60
+        @register_cue_event_lambda.call(Time.now, p, @system_init_thread_id, d, b, m, address, args, 0)
+      end
+
+      updated_midi_ins_handler = lambda do |ins|
+        desc = ins.join("\n")
+        __msg_queue.push({:type => :midi_in_ports, :val => desc})
+      end
+
+      updated_midi_outs_handler = lambda do |outs|
+        desc = outs.join("\n")
+        __msg_queue.push({:type => :midi_out_ports, :val => desc})
+      end
+
+      # @tau_api = TauAPI.new(ports,
+      #                       {
+      #                         external_osc_cue: external_osc_cue_handler,
+      #                         internal_cue: internal_cue_handler,
+      #                         updated_midi_ins: updated_midi_ins_handler,
+      #                         updated_midi_outs: updated_midi_outs_handler
+      #                       })
+
+      @tau_api = MockTauAPI.new
+
+      begin
+        @gitsave = GitSave.new(Paths.project_path)
+      rescue
+        @gitsave = nil
+      end
+
+      @save_queue = SizedQueue.new(20)
+
+      @save_t = Thread.new do
+        __system_thread_locals.set_local(:sonic_pi_local_thread_group, :save_loop)
+        Kernel.loop do
+          event = @save_queue.pop
+          id, content = *event
+          filename = id + '.spi'
+          path = File.expand_path("#{Paths.project_path}/#{filename}")
+          content = filter_for_save(content)
+          begin
+            File.open(path, 'w') {|f| f.write(content) }
+            @gitsave.save!(filename, content, "#{@version} -- #{@session_id} -- ")
+          rescue Exception => e
+            log "Exception saving buffer #{filename}:\n#{e.inspect}"
+            ##TODO: remove this and ensure that git saving actually works
+            ##instead of cowardly hiding the issue!
+          end
         end
+      end
+
+      @system_state.set 0, 0, ThreadId.new(-2), 0, 0, 60, :sched_ahead_time, default_sched_ahead_time
+
+      __info "Welcome to Sonic Pi #{version}", 1
 
+      __info "Running on Ruby v#{RUBY_VERSION}"
+
+      __info "Initialised Erlang OSC Scheduler"
+
+      if safe_mode?
+        __info "!!WARNING!! - file permissions issue:\n   Unable to write to folder #{Paths.home_dir_path} \n   Booting in SAFE MODE.\n   Buffer auto-saving is disabled, please save your work manually.", 1
       end
 
+      log "Unable to initialise git repo at #{Paths.project_path}" unless @gitsave
+      load_snippets(Paths.snippets_path, true)
     end
 
+
     def __error(e, m=nil)
       raise e
     end
@@ -92,7 +216,7 @@ def run(&blk)
       job           = Thread.new do
         Thread.current.abort_on_exception = true
 
-        reg_job 0, Thread.current
+        register_job! 0, Thread.current
         __system_thread_locals.set_local :sonic_pi_local_thread_group, "job-#{id}"
         __system_thread_locals.set_local :sonic_pi_spider_thread_id_path, ThreadId.new(id)
         __system_thread_locals.set :sonic_pi_spider_job_id, id