cuboid 0.0.0 → 0.0.1alpha

data/spec/support/fixtures/services/echo.rb

@@ -0,0 +1,64 @@
+class Cuboid::RPC::Server::Dispatcher
+class Service::Echo < Service
+
+    private :instances
+    public  :instances
+
+    def test_dispatcher
+        dispatcher.class == Cuboid::RPC::Server::Dispatcher
+    end
+
+    def test_opts
+        dispatcher.instance_eval{ @options } == options
+    end
+
+    def test_node
+        node.class == Node
+    end
+
+    def test_map_instances( &block )
+        each = proc do |instance, iterator|
+            iterator.return [instance.url, instance.token]
+        end
+        after = proc { |i| block.call Hash[i] }
+
+        map_instances( each, after )
+    end
+
+    def test_each_instance
+        i = 0
+        each_instance do |instance, iterator|
+            i += 1
+            instance.options.set( authorized_by: "test#{i}@test.test") { |p| iterator.next }
+        end
+        true
+    end
+
+    def test_iterator_for
+        iterator_for( instances ).class == Arachni::Reactor::Iterator
+    end
+
+    def test_connect_to_dispatcher( url, &block )
+        connect_to_dispatcher( url ).alive? { |b| block.call b }
+    end
+
+    def test_connect_to_instance( *args, &block )
+        connect_to_instance( *args ).busy?{ |b| block.call !!b }
+    end
+
+    def test_defer( *args, &block )
+        defer do
+            block.call args
+        end
+    end
+
+    def test_run_asap( *args, &block )
+        run_asap { block.call args }
+    end
+
+    def echo( *args )
+        args
+    end
+
+end
+end

data/spec/support/helpers/framework.rb

@@ -0,0 +1,3 @@
+def issues
+    Cuboid::Data.issues.all
+end

data/spec/support/helpers/matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_same_array_as do |expected_array|
+    match do |actual_array|
+        Set.new(actual_array) == Set.new(expected_array)
+    end
+end

data/spec/support/helpers/misc.rb

@@ -0,0 +1,3 @@
+def available_port
+    Cuboid::Utilities.available_port
+end

data/spec/support/helpers/paths.rb

@@ -0,0 +1,15 @@
+def name_from_filename
+    File.basename( caller.first.split( ':' ).first, '_spec.rb' )
+end
+
+def spec_path
+    File.expand_path( File.dirname( File.absolute_path( __FILE__ )  ) + '/../../' ) + '/'
+end
+
+def support_path
+    "#{spec_path}support/"
+end
+
+def fixtures_path
+    "#{support_path}fixtures/"
+end

data/spec/support/helpers/request_helpers.rb

@@ -0,0 +1,38 @@
+module RequestHelpers
+    include Rack::Test::Methods
+
+    def app
+        Cuboid::Rest::Server
+    end
+
+    def response_data
+        JSON.load response.body
+    rescue => e
+        ap response
+        raise
+    end
+
+    def pretty_response_body
+        JSON.pretty_generate( response_data )
+    end
+
+    def response_body
+        response.body
+    end
+
+    def response_code
+        response.status
+    end
+
+    def response
+        last_response
+    end
+
+    %w(get post put delete).each do |m|
+        define_method m do |path, parameters = nil, headers = {}|
+            super( path, (parameters.to_json if parameters), headers )
+        end
+    end
+
+    extend self
+end

data/spec/support/helpers/requires.rb

@@ -0,0 +1,8 @@
+def require_lib( path )
+    require Cuboid::Options.paths.lib + path
+end
+
+def require_testee
+    require Kernel.caller.first.split( ':' ).first.
+                gsub( '/spec/cuboid', '/lib/cuboid' ).gsub( '_spec', '' )
+end

data/spec/support/helpers/resets.rb

@@ -0,0 +1,52 @@
+# Order is important.
+INSTANCES = [
+    Cuboid::Application
+]
+INSTANCES.each(&:_spec_instances_collect!)
+
+def reset_options
+    options = Cuboid::Options
+    options.reset
+
+    options.paths.logs      = spec_path + 'support/logs/'
+    options.paths.reports   = spec_path + 'support/reports/'
+    options.paths.snapshots = spec_path + 'support/snapshots/'
+    options.snapshot.path   = options.paths.snapshots
+
+    options.rpc.server_address = '127.0.0.1'
+
+    options
+end
+
+def cleanup_instances
+    INSTANCES.each do |i|
+        i._spec_instances_cleanup
+    end
+end
+
+def reset_framework
+    Cuboid::UI::OutputInterface.initialize
+    # Cuboid::UI::Output.debug_on( 999999 )
+    # Cuboid::UI::Output.verbose_on
+    # Cuboid::UI::Output.mute
+
+    Cuboid::Application.reset
+end
+
+def reset_all
+    reset_options
+    reset_framework
+end
+
+def processes_killall
+    instance_killall
+    dispatcher_killall
+    scheduler_killall
+    process_killall
+    process_kill_reactor
+end
+
+def killall
+    processes_killall
+    web_server_killall
+end

data/spec/support/helpers/web_server.rb

@@ -0,0 +1,15 @@
+def web_server_manager
+    ENV['WEB_SERVER_DISPATCHER'] ? WebServerClient.instance : WebServerManager
+end
+
+def web_server_url_for( *args )
+    web_server_manager.url_for( *args )
+end
+
+def web_server_spawn( *args )
+    web_server_manager.spawn( *args )
+end
+
+def web_server_killall
+    web_server_manager.killall
+end

data/spec/support/lib/factory.rb

@@ -0,0 +1,107 @@
+class Factory
+class <<self
+
+    # Clears all instructions and aliases.
+    def reset
+        @instructions = {}
+        @aliases      = {}
+    end
+
+    # Defines instruction on how to create a given object.
+    #
+    # There are 2 ways to define a factory instruction:
+    #
+    #   * Using a `generator` block to return an object.
+    #   * Using the `options` to generate an object.
+    #
+    # @param    [Symbol]    object_name     Name of the object.
+    # @param    [Hash]    options   Generation options.
+    # @option   options [Class] :class
+    #   Class to instantiate.
+    # @option   options [Hash] :options
+    #   Options to use to instantiate the `:class`.
+    def define( object_name, options = {}, &generator )
+        @instructions[object_name] = {
+            options:   options.dup,
+            generator: generator
+        }
+    end
+
+    # @param    [Symbol]    object_name     Name of the object.
+    # @param    []  args
+    #   If a `generator` block has been provided via {#define}, those arguments
+    #   will be passed to it.
+    #
+    #   If `:options` have been passed to {#define}, the `args` will be merged
+    #   with them before instantiating the object.
+    def create( object_name, *args )
+        ensure_defined( object_name )
+
+        instructions = instructions_for( object_name )
+
+        if instructions[:generator]
+            instructions[:generator].call( *args )
+        elsif (options = instructions[:options]).include? :class
+            options[:class].new( options[:options].merge( args.first || {} ) )
+        end
+    end
+
+    # @param    [Symbol]    object_name     Name of the object.
+    # @return   [Hash]  Instantiation options passed to {#define}.
+    def options_for( object_name )
+        instructions_for( object_name )[:options][:options].freeze
+    end
+
+    # @note {#create} helper.
+    #
+    # @param    [Symbol]    object_name     Name of the object.
+    # @return   [Object]    Instantiated object.
+    def []( object_name )
+        create object_name
+    end
+
+    # @param    [Symbol]    object_name
+    #   Name of the new object.
+    # @param    [Symbol]    existing_object_name
+    #   Name of the existing object.
+    def alias( object_name, existing_object_name )
+        ensure_defined( existing_object_name )
+        @aliases[object_name] = existing_object_name
+    end
+
+    # @param    [Symbol]    object_name Object to delete.
+    def delete( object_name )
+        @instructions.delete object_name
+    end
+
+    # @param    [Symbol]    object_name Alias to delete.
+    def unalias( object_name )
+        @aliases.delete object_name
+        nil
+    end
+
+    # @param    [Symbol]    object_name
+    #   Name of the new object.
+    # @return   [Bool]
+    #   `true` if instructions have been {#defined} for the `object_name`,
+    #   `false` otherwise.
+    def defined?( object_name )
+        !!instructions_for( object_name ) rescue false
+    end
+
+    private
+
+    def instructions_for( object_name )
+        instructions = @instructions[object_name] || @instructions[@aliases[object_name]]
+        return instructions if instructions
+
+        fail ArgumentError, "Factory '#{object_name}' not defined."
+    end
+
+    def ensure_defined( object_name )
+        !!instructions_for( object_name )
+    end
+end
+reset
+
+end

data/spec/support/lib/web_server_client.rb

@@ -0,0 +1,41 @@
+require 'arachni/rpc'
+
+# @note Needs `ENV['WEB_SERVER_DISPATCHER']` in the format of `host:port`.
+#
+# {WebServerManager}-API-compatible client for the {WebServerDispatcher}.
+#
+# Delegates test webserver creation to the machine running {WebServerDispatcher},
+# for hosts that lack support for fast servers (like Windows, which can't run
+# Thin, Puma etc.).
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class WebServerClient < Arachni::RPC::Proxy
+    include Singleton
+
+    def initialize( options = {} )
+        @host, port = ENV['WEB_SERVER_DISPATCHER'].split( ':' )
+
+        Arachni::Reactor.global.run_in_thread if !Arachni::Reactor.global.running?
+
+        client = Arachni::RPC::Client.new( host: @host, port: port )
+        super client, 'server'
+    end
+
+    def protocol_for( name )
+        name.to_s.include?( 'https' ) ? 'https' : 'http'
+    end
+
+    def address_for( name )
+        @host
+    end
+
+    def up?( name )
+        Typhoeus.get(
+            url_for( name, false ),
+            ssl_verifypeer: false,
+            ssl_verifyhost: 0,
+            forbid_reuse:   true
+        ).code != 0
+    end
+
+end

data/spec/support/lib/web_server_dispatcher.rb

@@ -0,0 +1,25 @@
+require_relative '../../../lib/cuboid/processes/manager'
+require_relative '../../../lib/cuboid/processes/helpers'
+require_relative '../../support/helpers/paths'
+require_relative 'web_server_manager'
+require 'arachni/rpc'
+
+# @note Needs `ENV['WEB_SERVER_DISPATCHER']` in the format of `host:port`.
+#
+# Exposes the {WebServerManager} over RPC.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class WebServerDispatcher
+
+    def initialize( options = {} )
+        host, port = ENV['WEB_SERVER_DISPATCHER'].split( ':' )
+
+        manager = WebServerManager.instance
+        manager.address = host
+
+        rpc = Cuboid::RPC::Server.new( host: host, port: port.to_i )
+        rpc.add_handler( 'server', manager )
+        rpc.run
+    end
+
+end

data/spec/support/lib/web_server_manager.rb

@@ -0,0 +1,118 @@
+class WebServerManager
+    include Singleton
+    include Cuboid::Utilities
+
+    attr_reader   :lib
+    attr_accessor :address
+
+    def initialize
+        @lib     = "#{support_path}/servers/"
+        @servers = {}
+        @address = Socket.gethostname
+
+        Dir.glob( File.join( @lib + '**', '*.rb' ) ) do |path|
+            @servers[normalize_name( File.basename( path, '.rb' ) )] = {
+                path: path
+            }
+        end
+    end
+
+    def spawn( name )
+        server_info = data_for( name )
+
+        10.times do
+            server_info[:port] = Cuboid::Utilities.available_port
+            server_info[:pid]  = Process.spawn(
+                RbConfig.ruby, server_info[:path],
+                '-p', server_info[:port].to_s,
+                '-o', address_for( name )
+            )
+            Process.detach server_info[:pid]
+
+            begin
+                Timeout.timeout( 10 ) { sleep 0.1 while !up?( name ) }
+
+                return url_for( name, false )
+            rescue Timeout::Error
+                kill name
+            end
+        end
+
+        abort "Server '#{name}' never started!"
+    end
+
+    def url_for( name, lazy_start = true )
+        spawn( name ) if lazy_start && !up?( name )
+
+        "#{protocol_for( name )}://#{address_for( name )}:#{port_for( name )}"
+    end
+
+    def address_for( name )
+        @address
+    end
+
+    def port_for( name )
+        data_for( name )[:port]
+    end
+
+    def protocol_for( name )
+        name.to_s.include?( 'https' ) ? 'https' : 'http'
+    end
+
+    def kill( name )
+        server_info = data_for( name )
+        return if !server_info[:pid]
+
+        r = process_kill( server_info[:pid] )
+
+        if r
+            server_info.delete( :pid )
+            server_info.delete( :port )
+        end
+
+        r
+    end
+
+    def killall
+        @servers.keys.each { |name| kill name }
+        nil
+    end
+
+    def up?( name )
+        return false if !data_for(name)[:port]
+
+        Typhoeus.get(
+            url_for( name, false ),
+            ssl_verifypeer: false,
+            ssl_verifyhost: 0,
+            forbid_reuse:   true
+        ).code != 0
+    end
+
+    def self.method_missing( sym, *args, &block )
+        if instance.respond_to?( sym )
+            instance.send( sym, *args, &block )
+        else
+            super( sym, *args, &block )
+        end
+    end
+
+    def self.respond_to?( m )
+        super( m ) || instance.respond_to?( m )
+    end
+
+    private
+
+    def normalize_name( name )
+        name.to_s.to_sym
+    end
+
+    def data_for( name )
+        @servers[normalize_name( name )]
+    end
+
+    def set_data_for(name, data)
+        @servers[normalize_name(name)] = data
+    end
+
+end