hyper-spec 1.0.alpha1.3 → 1.0.alpha1.8

data/lib/hyper-spec/expectations.rb

@@ -0,0 +1,64 @@
+# don't put this in directory lib/rspec/ as that will cause stack overflow with rails/rspec loads
+module RSpec
+  module Expectations
+    class ExpectationTarget; end
+    module HyperSpecInstanceMethods
+      def self.included(base)
+        base.include HyperSpec::Helpers
+      end
+
+      def to_on_client(matcher, message = nil, &block)
+        evaluate_client.to(matcher, message, &block)
+      end
+
+      alias on_client_to to_on_client
+      alias to_then to_on_client
+      alias then_to to_on_client
+
+      def to_on_client_not(matcher, message = nil, &block)
+        evaluate_client.not_to(matcher, message, &block)
+      end
+
+      alias on_client_to_not to_on_client_not
+      alias on_client_not_to to_on_client_not
+      alias to_not_on_client to_on_client_not
+      alias not_to_on_client to_on_client_not
+      alias then_to_not to_on_client_not
+      alias then_not_to to_on_client_not
+      alias to_not_then to_on_client_not
+      alias not_to_then to_on_client_not
+
+      private
+
+      def evaluate_client
+        source = add_opal_block(@args_str, @target)
+        value = @target.binding.eval("evaluate_ruby(#{source.inspect}, {}, {})")
+        ExpectationTarget.for(value, nil)
+      end
+    end
+
+    class OnClientWithArgsTarget
+      include HyperSpecInstanceMethods
+
+      def initialize(target, args)
+        unless args.is_a? Hash
+          raise ExpectationNotMetError,
+                "You must pass a hash of local var, value pairs to the 'with' modifier"
+        end
+
+        @target = target
+        @args_str = args.collect do |name, value|
+          set_local_var(name, value)
+        end.join("\n")
+      end
+    end
+
+    class BlockExpectationTarget < ExpectationTarget
+      include HyperSpecInstanceMethods
+
+      def with(args)
+        OnClientWithArgsTarget.new(@target, args)
+      end
+    end
+  end
+end

data/lib/hyper-spec/helpers.rb

@@ -0,0 +1,225 @@
+module HyperSpec
+  module Helpers
+    include Internal::ClientExecution
+    include Internal::Controller
+    include Internal::ComponentMount
+    include Internal::CopyLocals
+    include Internal::WindowSizing
+
+    ##
+    # Mount a component on a page, with a full execution environment
+    # i.e. `mount('MyComponent')` will mount MyComponent on the page.
+
+    # The params argument is a hash of parameters to be passed to the
+    # component.
+    # i.e. `mount('MyComponent', title: 'hello')`
+
+    # The options parameters can set things like:
+    # + controller: the controller class, defaults to HyperSpecTestController
+    # + no_wait: do not wait for any JS to finish executing before proceeding with the spec
+    # + render_on: :client_only (default), :client_and_server, or :server_only
+    # + style_sheet: style sheet file defaults to 'application'
+    # + javascript:  javascript file defaults to 'application'
+    # + layout: if provided will use the specified layout otherwise no layout is used
+    # Note that if specifying options the params will have to inclosed in their
+    # own hash.
+    # i.e. `mount('MyComponent', { title: 'hello' }, render_on: :server_only)`
+    # The options can be specified globally using the client_options method (see below.)
+
+    # You may provide a block to mount.  This block will be executed on the client
+    # before mounting the component.  This is useful for setting up test
+    # components or modifying a components behavior.
+    # i.e.
+    # ```ruby
+    # mount('MyComponent', title: 'hello') do
+    #   # this line will be printed on the client console
+    #   puts "I'm about to mount my component!"
+    # end
+    # ```
+    def mount(component_name = nil, params = nil, opts = {}, &block)
+      unless params
+        params = opts
+        opts = {}
+      end
+      internal_mount(component_name, params, client_options(opts), &block)
+    end
+
+    ##
+    # The following methods retrieve callback and event responses from
+    # the mounted components.  The history methods contain the array of all
+    # responses, while last_... returns the last response.
+    # i.e. event_history_for(:save) would return any save events
+    # that the component has raised.
+
+    %i[
+      callback_history_for last_callback_for clear_callback_history_for
+      event_history_for last_event_for clear_event_history_for
+    ].each do |method|
+      define_method(method) do |event_name|
+        evaluate_ruby(
+          "Hyperstack::Internal::Component::TopLevelRailsComponent.#{method}('#{event_name}')"
+        )
+      end
+    end
+
+    ##
+    # Define a code block to be prefixed to the mount code.
+    # Useful in before(:each) blocks.
+
+    # In legacy code this was called `on_client`. To get the legacy
+    # behavior alias on_client before_mount
+    # but be aware that on_client is now by default the method
+    # for executing a block of code on the client which was called
+    # evaluate_ruby
+
+    def before_mount(&block)
+      @_hyperspec_private_client_code =
+        "#{@_hyperspec_private_client_code}#{add_opal_block('', block)}"
+    end
+
+    # Execute the block both on the client and on the server.  Useful
+    # for mocking isomorphic classes such as ActiveRecord models.
+
+    def isomorphic(&block)
+      yield
+      if page.instance_variable_get('@hyper_spec_mounted')
+        internal_evaluate_ruby(&block)
+      else
+        before_mount(&block)
+      end
+    end
+
+    # Allows options to the mount method to be specified globally
+
+    def client_option(opts = {})
+      @_hyperspec_private_client_options ||= { arity_check: default_arity_check }
+      @_hyperspec_private_client_options.merge! opts
+      build_var_inclusion_lists
+      @_hyperspec_private_client_options
+    end
+
+    def default_arity_check
+      Rails.application.config.opal.arity_check_enabled if defined? Rails
+    rescue StandardError
+      false
+    end
+
+    alias client_options client_option
+
+    ##
+    # shorthand for mount with no params (which will effectively reload the page.)
+    # also aliased as reload_page
+    def load_page
+      mount
+    end
+
+    alias reload_page load_page
+
+    ##
+    # evaluate a block (or string) on the client
+    #   on_client(<optional str>, <opts and/or vars>, &block)
+    #
+    # normal use is to pass a block that will be compiled to the client
+    # but if the ruby code can be supplied as a string in the first arg.
+
+    # opts are passed on to JSON.parse when retrieving the result
+    # from the client.
+
+    # vars is a hash of name: value pairs.  Each name will be initialized
+    # as a local variable on the client.
+
+    # example: on_client(x: 12) { x * x } => 144
+
+    # in legacy code on_client was called before_mount
+    # to get legacy on_client behavior you can alias
+    # on_client before_mount
+
+    alias on_client internal_evaluate_ruby
+
+    # attempt to set the window to a particular size
+
+    def size_window(width = nil, height = nil)
+      hs_internal_resize_to(*determine_size(width, height))
+    rescue StandardError
+      true
+    end
+
+    # same signature as on_client, but just returns the compiled
+    # js code.  Useful for debugging suspected issues with the
+    # Opal compiler, etc.
+
+    def to_js(*args, &block)
+      opal_compile(*process_params(*args, &block))
+    end
+
+    # legacy methods for backwards compatibility
+    # these may be removed in a future version
+
+    def expect_evaluate_ruby(*args, &block)
+      expect(evaluate_ruby(*args, &block))
+    end
+
+    alias evaluate_ruby internal_evaluate_ruby
+    alias evaluate_promise evaluate_ruby
+    alias expect_promise expect_evaluate_ruby
+
+    def run_on_client(&block)
+      script = opal_compile(Unparser.unparse(Parser::CurrentRuby.parse(block.source).children.last))
+      page.execute_script(script)
+    end
+
+    def insert_html(str)
+      @_hyperspec_private_html_block = "#{@_hyperspec_private_html_block}\n#{str}"
+    end
+
+    def ppr(str)
+      js = opal_compile(str)
+      execute_script("console.log(#{js})")
+    end
+
+    def debugger
+      `debugger`
+      nil
+    end
+
+    def add_class(class_name, style)
+      @_hyperspec_private_client_code =
+        "#{@_hyperspec_private_client_code}ComponentHelpers.add_class('#{class_name}', #{style})\n"
+    end
+
+    def attributes_on_client(model)
+      evaluate_ruby("#{model.class.name}.find(#{model.id}).attributes").symbolize_keys
+    end
+
+    ### --- Debugging Helpers ----
+
+    def pause(message = nil)
+      if message
+        puts message
+        internal_evaluate_ruby "puts #{message.inspect}.to_s + ' (type go() to continue)'"
+      end
+
+      page.evaluate_script('window.hyper_spec_waiting_for_go = true')
+
+      loop do
+        sleep 0.25
+        break unless page.evaluate_script('window.hyper_spec_waiting_for_go')
+      end
+    end
+
+    def open_in_chrome
+      # if ['linux', 'freebsd'].include?(`uname`.downcase)
+      #   `google-chrome http://#{page.server.host}:#{page.server.port}#{page.current_path}`
+      # else
+      `open http://#{page.server.host}:#{page.server.port}#{page.current_path}`
+      # end
+
+      loop do
+        sleep 1.hour
+      end
+    end
+
+    # short hand for use in pry sessions
+    alias c? internal_evaluate_ruby
+  end
+end

data/lib/hyper-spec/internal/client_execution.rb

@@ -0,0 +1,94 @@
+module HyperSpec
+  module Internal
+    module ClientExecution
+      def internal_evaluate_ruby(*args, &block)
+        insure_page_loaded
+        add_promise_execute_and_wait(*process_params(*args, &block))
+      end
+
+      private
+
+      def add_opal_block(str, block)
+        return str unless block
+
+        source = block.source
+        ast = Parser::CurrentRuby.parse(source)
+        ast = find_block(ast)
+        raise "could not find block within source: #{block.source}" unless ast
+
+        "#{add_locals(str, block)}\n#{Unparser.unparse ast.children.last}"
+      end
+
+      def add_promise_execute_and_wait(str, opts)
+        js = opal_compile(add_promise_wrapper(str))
+        page.execute_script("window.hyper_spec_promise_result = false; #{js}")
+        Timeout.timeout(Capybara.default_max_wait_time) do
+          loop do
+            break if page.evaluate_script('!!window.hyper_spec_promise_result')
+            page.evaluate_script('!!window.hyper_spec_promise_failed && Opal.Opal.$raise(window.hyper_spec_promise_failed)')
+
+            sleep 0.25
+          end
+        end
+        JSON.parse(page.evaluate_script('window.hyper_spec_promise_result.$to_json()'), opts).first
+      end
+
+      def add_promise_wrapper(str)
+        <<~RUBY
+          (#{str}).tap do |r|
+            if defined?(Promise) && r.is_a?(Promise)
+              r.then { |args| `window.hyper_spec_promise_result = [args]` }
+               .fail { |e| `window.hyper_spec_promise_failed = e` }
+            else
+              #after(0) do
+                #puts "setting window.hyper_spec_promise_result = [\#{r}]"
+                `window.hyper_spec_promise_result = [r]`
+              #end
+            end
+          end
+        RUBY
+      end
+
+      def find_block(node)
+        # find a block with the ast tree.
+
+        return false unless node.class == Parser::AST::Node
+        return node if the_node_you_are_looking_for?(node)
+
+        node.children.each do |child|
+          found = find_block(child)
+          return found if found
+        end
+        false
+      end
+
+      def process_params(*args, &block)
+        args = ['', *args] if args[0].is_a? Hash
+        args = [args[0], {}, args[1] || {}] if args.length < 3
+        str, opts, vars = args
+        vars.each do |name, value|
+          str = "#{name} = #{value.inspect}\n#{str}"
+        end
+        [add_opal_block(str, block), opts]
+      end
+
+      def the_node_you_are_looking_for?(node)
+        # we could also check that the block is going to the right method
+        #   respond_to?(node.children.first.children[1]) &&
+        #   method(node.children.first.children[1]) == method(:evaluate_ruby)
+        # however that does not work for expect { ... }.on_client_to ...
+        # because now the block is being sent to expect... so we could
+        # check the above OR node.children.first.children[1] == :expect
+        # but what if there are two blocks? on and on...
+        node.type == :block &&
+          node.children.first.class == Parser::AST::Node &&
+          node.children.first.type == :send
+      end
+
+
+      def opal_compile(str)
+        Opal.hyperspec_compile(str, arity_check: client_options[:arity_check])
+      end
+    end
+  end
+end

data/lib/hyper-spec/internal/component_mount.rb

@@ -0,0 +1,140 @@
+module HyperSpec
+  module Internal
+    module ComponentMount
+      private
+
+      TEST_CODE_KEY = 'hyper_spec_prerender_test_code.js'.freeze
+
+      # rubocop:disable Metrics/MethodLength
+      def add_block_with_helpers(component_name, opts, block)
+        return unless block || @_hyperspec_private_client_code || component_name.nil?
+
+        block_with_helpers = <<-RUBY
+          module ComponentHelpers
+            def self.js_eval(s)
+              `eval(s)`
+            end
+            def self.dasherize(s)
+              res = %x{
+                s.replace(/[-_\\s]+/g, '-')
+                .replace(/([A-Z\\d]+)([A-Z][a-z])/g, '$1-$2')
+                .replace(/([a-z\\d])([A-Z])/g, '$1-$2')
+                .toLowerCase()
+              }
+              res
+            end
+            def self.add_class(class_name, styles={})
+              style = styles.collect { |attr, value| "\#{dasherize(attr)}:\#{value}" }.join("; ")
+              cs = class_name.to_s
+              %x{
+                var style_el = document.createElement("style");
+                var css = "." + cs + " { " + style + " }";
+                style_el.type = "text/css";
+                if (style_el.styleSheet){
+                  style_el.styleSheet.cssText = css;
+                } else {
+                  style_el.appendChild(document.createTextNode(css));
+                }
+                document.head.appendChild(style_el);
+              }
+            end
+          end
+          #{test_dummy}
+          #{@_hyperspec_private_client_code}
+          #{"#{add_locals('', block)}\n#{Unparser.unparse(Parser::CurrentRuby.parse(block.source).children.last)}" if block}
+        RUBY
+        @_hyperspec_private_client_code = nil
+        opts[:code] = opal_compile(block_with_helpers)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def build_test_url_for(controller = nil, ping = nil)
+        id = ping ? 'ping' : Controller.test_id
+        "/#{route_root_for(controller)}/#{id}"
+      end
+
+      def insure_page_loaded(only_if_code_or_html_exists = nil)
+        return if only_if_code_or_html_exists && !@_hyperspec_private_client_code && !@_hyperspec_private_html_block
+
+        # if we are not resetting between examples, or think its mounted
+        # then look for Opal, but if we can't find it, then ping to clear and try again
+        if !HyperSpec.reset_between_examples? || page.instance_variable_get('@hyper_spec_mounted')
+          r = evaluate_script('Opal && true') rescue nil
+          return if r
+
+          page.visit build_test_url_for(nil, true) rescue nil
+        end
+        load_page
+      end
+
+      def internal_mount(component_name, params, opts, &block)
+        # TODO:  refactor this
+        test_url = build_test_url_for(opts.delete(:controller))
+        add_block_with_helpers(component_name, opts, block)
+        send_params_to_controller_via_cache(test_url, component_name, params, opts)
+        setup_prerendering(opts)
+        page.instance_variable_set('@hyper_spec_mounted', false)
+        visit test_url
+        wait_for_ajax unless opts[:no_wait]
+        page.instance_variable_set('@hyper_spec_mounted', true)
+        Lolex.init(self, client_options[:time_zone], client_options[:clock_resolution])
+      end
+
+      def prerendering?(opts)
+        %i[both server_only].include?(opts[:render_on])
+      end
+
+      def send_params_to_controller_via_cache(test_url, component_name, params, opts)
+        component_name ||= 'Hyperstack::Internal::Component::TestDummy' if test_dummy
+        Controller.cache_write(
+          test_url,
+          [component_name, params, @_hyperspec_private_html_block, opts]
+        )
+        @_hyperspec_private_html_block = nil
+      end
+
+      # test_code_key = "hyper_spec_prerender_test_code.js"
+      # if defined? ::Hyperstack::Component
+      #   @@original_server_render_files ||= ::Rails.configuration.react.server_renderer_options[:files]
+      #   if opts[:render_on] == :both || opts[:render_on] == :server_only
+      #     unless opts[:code].blank?
+      #       ComponentTestHelpers.cache_write(test_code_key, opts[:code])
+      #       ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files + [test_code_key]
+      #       ::React::ServerRendering.reset_pool # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher doesnt look for cache changes
+      #     else
+      #       ComponentTestHelpers.cache_delete(test_code_key)
+      #       ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files
+      #       ::React::ServerRendering.reset_pool # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher doesnt look for cache changes
+      #     end
+      #   end
+      # end
+
+      def setup_prerendering(opts)
+        return unless defined?(::Hyperstack::Component) && prerendering?(opts)
+
+        @@original_server_render_files ||= ::Rails.configuration.react.server_renderer_options[:files]
+        ::Rails.configuration.react.server_renderer_options[:files] = @@original_server_render_files
+        if opts[:code].blank?
+          Controller.cache_delete(TEST_CODE_KEY)
+        else
+          Controller.cache_write(TEST_CODE_KEY, opts[:code])
+          ::Rails.configuration.react.server_renderer_options[:files] += [TEST_CODE_KEY]
+        end
+        ::React::ServerRendering.reset_pool
+        # make sure contexts are reloaded so they dont use code from cache, as the rails filewatcher
+        # doesnt look for cache changes
+      end
+
+      def test_dummy
+        return unless defined? ::Hyperstack::Component
+
+        <<-RUBY
+          class Hyperstack::Internal::Component::TestDummy
+            include Hyperstack::Component
+            render {}
+          end
+        RUBY
+      end
+    end
+  end
+end