opal-rails 2.0.3 → 3.0.0

data/spec/opal/rails/build_task_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'rake'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe 'opal:build task' do
+  before(:all) do
+    Rails.application.load_tasks unless Rake::Task.task_defined?('opal:build')
+  end
+
+  around do |example|
+    Dir.mktmpdir do |dir|
+      root = Pathname(dir)
+      source_path = root.join('app/opal')
+      build_path = root.join('app/assets/builds')
+      FileUtils.mkdir_p(source_path)
+      FileUtils.mkdir_p(build_path)
+
+      source_path.join('application.rb').write("require 'opal'\nputs 'built from task'\n")
+
+      config = Rails.application.config.opal
+      original_source_path = config.source_path
+      original_entrypoints_path = config.entrypoints_path
+      original_build_path = config.build_path
+      original_entrypoints = config.entrypoints
+      original_append_paths = config.append_paths
+      original_use_gems = config.use_gems
+      original_source_map_enabled = config.source_map_enabled if config.respond_to?(:source_map_enabled)
+
+      config.source_path = source_path
+      config.entrypoints_path = source_path
+      config.build_path = build_path
+      config.entrypoints = { 'application' => 'application.rb' }
+      config.append_paths = []
+      config.use_gems = []
+      config.source_map_enabled = true
+
+      example.run
+    ensure
+      config.source_path = original_source_path
+      config.entrypoints_path = original_entrypoints_path
+      config.build_path = original_build_path
+      config.entrypoints = original_entrypoints
+      config.append_paths = original_append_paths
+      config.use_gems = original_use_gems
+      config.source_map_enabled = original_source_map_enabled if config.respond_to?(:source_map_enabled)
+    end
+  end
+
+  it 'builds assets and writes an ownership manifest' do
+    Rake::Task['opal:build'].reenable
+    Rake::Task['opal:build'].invoke
+
+    build_path = Pathname(Rails.application.config.opal.build_path)
+
+    expect(build_path.join('application.js')).to exist
+    expect(build_path.join('application.js.map')).to exist
+    expect(build_path.join('.opal-build-manifest.json').read).to include('application.js')
+  end
+
+  it 'builds and prunes bulk-discovered entrypoints in :all mode' do
+    Dir.mktmpdir do |dir|
+      root = Pathname(dir)
+      source_path = root.join('app/assets/opal')
+      build_path = root.join('app/assets/builds')
+      FileUtils.mkdir_p(source_path.join('nested'))
+      FileUtils.mkdir_p(build_path)
+
+      source_path.join('application.rb').write("require 'opal'\nputs 'app entrypoint'\n")
+      source_path.join('dashboard.rb').write("require 'opal'\nputs 'dashboard entrypoint'\n")
+      source_path.join('nested/ignored.rb').write("require 'opal'\nputs 'ignore me'\n")
+
+      config = Rails.application.config.opal
+      original_source_path = config.source_path
+      original_entrypoints_path = config.entrypoints_path
+      original_build_path = config.build_path
+      original_entrypoints = config.entrypoints
+      original_append_paths = config.append_paths
+      original_use_gems = config.use_gems
+      original_source_map_enabled = config.source_map_enabled if config.respond_to?(:source_map_enabled)
+
+      config.source_path = source_path
+      config.entrypoints_path = source_path
+      config.build_path = build_path
+      config.entrypoints = :all
+      config.append_paths = []
+      config.use_gems = []
+      config.source_map_enabled = true
+
+      Rake::Task['opal:build'].reenable
+      Rake::Task['opal:build'].invoke
+
+      expect(build_path.join('application.js')).to exist
+      expect(build_path.join('dashboard.js')).to exist
+      expect(build_path.join('nested.js')).not_to exist
+      expect(build_path.join('.opal-build-manifest.json').read).to include('dashboard.js')
+
+      source_path.join('dashboard.rb').delete
+
+      Rake::Task['opal:build'].reenable
+      Rake::Task['opal:build'].invoke
+
+      expect(build_path.join('application.js')).to exist
+      expect(build_path.join('dashboard.js')).not_to exist
+      expect(build_path.join('.opal-build-manifest.json').read).not_to include('dashboard.js')
+    ensure
+      config.source_path = original_source_path
+      config.entrypoints_path = original_entrypoints_path
+      config.build_path = original_build_path
+      config.entrypoints = original_entrypoints
+      config.append_paths = original_append_paths
+      config.use_gems = original_use_gems
+      config.source_map_enabled = original_source_map_enabled if config.respond_to?(:source_map_enabled)
+    end
+  end
+end

data/spec/opal/rails/builder_runner_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe Opal::Rails::BuilderRunner do
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @root = Pathname(dir)
+      @source_path = @root.join('app/opal')
+      @entrypoints_path = @root.join('app/opal/entrypoints')
+      @build_path = @root.join('app/assets/builds')
+      @shared_path = @root.join('app/shared/opal')
+
+      FileUtils.mkdir_p(@source_path)
+      FileUtils.mkdir_p(@entrypoints_path)
+      FileUtils.mkdir_p(@build_path)
+      FileUtils.mkdir_p(@shared_path)
+
+      example.run
+    end
+  end
+
+  it 'builds configured entrypoints and writes source maps' do
+    @source_path.join('message.rb').write("module Message\n  def self.text\n    'hello from opal'\n  end\nend\n")
+    @entrypoints_path.join('application.rb').write("require 'opal'\nrequire 'message'\nputs Message.text\n")
+
+    config = ActiveSupport::OrderedOptions.new
+    config.source_path = @source_path
+    config.entrypoints_path = @entrypoints_path
+    config.build_path = @build_path
+    config.append_paths = []
+    config.use_gems = []
+    config.source_map_enabled = true
+
+    result = described_class.new(config: config).build(
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    expect(result[:outputs]).to contain_exactly('application.js', 'application.js.map')
+    expect(@build_path.join('application.js').read).to include('sourceMappingURL=application.js.map')
+    expect(@build_path.join('application.js').read).to include('hello from opal')
+    expect(@build_path.join('application.js.map').read).to include('"version"')
+    expect(result[:dependencies]['application']).to include(@entrypoints_path.join('application.rb').to_s)
+    expect(result[:dependencies]['application']).to include(@source_path.join('message.rb').to_s)
+  end
+
+  it 'builds the file from entrypoints_path when source roots share a basename' do
+    @source_path.join('application.rb').write("puts 'support file'\n")
+    @entrypoints_path.join('application.rb').write("require 'opal'\nputs 'entrypoint file'\n")
+
+    config = ActiveSupport::OrderedOptions.new
+    config.source_path = @source_path
+    config.entrypoints_path = @entrypoints_path
+    config.build_path = @build_path
+    config.append_paths = []
+    config.use_gems = []
+    config.source_map_enabled = false
+
+    described_class.new(config: config).build(
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    built_source = @build_path.join('application.js').read
+    expect(built_source).to include('entrypoint file')
+    expect(built_source).not_to include('support file')
+  end
+
+  it 'resolves requires from configured append_paths' do
+    @shared_path.join('shared_message.rb').write("module SharedMessage\n  def self.text\n    'hello from append paths'\n  end\nend\n")
+    @entrypoints_path.join('application.rb').write("require 'opal'\nrequire 'shared_message'\nputs SharedMessage.text\n")
+
+    config = ActiveSupport::OrderedOptions.new
+    config.source_path = @source_path
+    config.entrypoints_path = @entrypoints_path
+    config.build_path = @build_path
+    config.append_paths = [@shared_path]
+    config.use_gems = []
+    config.source_map_enabled = true
+
+    result = described_class.new(config: config).build(
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    expect(@build_path.join('application.js').read).to include('hello from append paths')
+    expect(result[:dependencies]['application']).to include(@shared_path.join('shared_message.rb').to_s)
+  end
+
+  it 'forwards append_paths and use_gems to the builder' do
+    fake_builder_class = Class.new do
+      class << self
+        attr_accessor :instances
+      end
+
+      self.instances = []
+
+      attr_reader :appended_paths, :built_files, :used_gems
+
+      def initialize(**)
+        @appended_paths = []
+        @built_files = []
+        @used_gems = []
+        self.class.instances << self
+      end
+
+      def append_paths(*paths)
+        appended_paths.concat(paths)
+      end
+
+      def use_gem(gem_name)
+        used_gems << gem_name
+      end
+
+      def build(relative_source_file)
+        built_files << relative_source_file
+      end
+
+      def to_s
+        '// fake builder output'
+      end
+
+      def source_map
+        Struct.new(:to_json).new('{"version":3}')
+      end
+
+      def dependent_files
+        []
+      end
+    end
+
+    @entrypoints_path.join('application.rb').write("puts 'noop'\n")
+
+    config = ActiveSupport::OrderedOptions.new
+    config.source_path = @source_path
+    config.entrypoints_path = @entrypoints_path
+    config.build_path = @build_path
+    config.append_paths = [@shared_path]
+    config.use_gems = %w[cannonbol browser]
+    config.source_map_enabled = false
+
+    described_class.new(config: config, builder_class: fake_builder_class).build(
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    fake_builder = fake_builder_class.instances.fetch(0)
+    expect(fake_builder.appended_paths).to include(@source_path.expand_path.to_s)
+    expect(fake_builder.appended_paths).to include(@entrypoints_path.expand_path.to_s)
+    expect(fake_builder.appended_paths).to include(@shared_path.expand_path.to_s)
+    expect(fake_builder.used_gems).to eq(%w[cannonbol browser])
+    expect(fake_builder.built_files).to eq(['application.rb'])
+  end
+end

data/spec/opal/rails/clobber_task_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+RSpec.describe 'opal:clobber task' do
+  let(:tasks_path) { File.expand_path('../../../../lib/tasks/opal.rake', __dir__) }
+
+  before do
+    Rake.application = Rake::Application.new
+    Rails.application.load_tasks unless Rake::Task.task_defined?('opal:clobber')
+    load tasks_path unless Rake::Task.task_defined?('opal:clobber')
+  end
+
+  after do
+    Rake.application = nil
+  end
+
+  it 'removes only Opal-owned outputs and leaves unrelated files alone' do
+    Dir.mktmpdir do |tmpdir|
+      app_root = Pathname(tmpdir)
+      build_path = app_root.join('app/assets/builds')
+      FileUtils.mkdir_p(build_path)
+
+      application_js = build_path.join('application.js')
+      application_map = build_path.join('application.js.map')
+      unrelated = build_path.join('application.css')
+      keep_file = build_path.join('.keep')
+
+      application_js.write('// opal output')
+      application_map.write('{"version":3}')
+      unrelated.write('body {}')
+      keep_file.write('')
+
+      manifest = Opal::Rails::OutputsManifest.new(build_path: build_path)
+      manifest.write!(%w[application.js application.js.map])
+
+      original_build_path = Rails.application.config.opal.build_path
+      Rails.application.config.opal.build_path = build_path
+
+      begin
+        task = Rake::Task['opal:clobber']
+        task.reenable
+        task.invoke
+
+        expect(application_js).not_to exist
+        expect(application_map).not_to exist
+        expect(build_path.join(Opal::Rails::OutputsManifest::FILE_NAME)).not_to exist
+        expect(unrelated).to exist
+        expect(keep_file).to exist
+      ensure
+        Rails.application.config.opal.build_path = original_build_path
+      end
+    end
+  end
+end

data/spec/opal/rails/entrypoints_resolver_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe Opal::Rails::EntrypointsResolver do
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @entrypoints_path = Pathname(dir)
+      example.run
+    end
+  end
+
+  it 'resolves an explicit mapping' do
+    @entrypoints_path.join('application.rb').write("puts 'hello'\n")
+
+    resolver = described_class.new(
+      entrypoints_path: @entrypoints_path,
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    expect(resolver.resolve).to eq('application' => 'application.rb')
+  end
+
+  it 'rejects missing explicit files' do
+    resolver = described_class.new(
+      entrypoints_path: @entrypoints_path,
+      entrypoints: { 'application' => 'application.rb' }
+    )
+
+    expect { resolver.resolve }
+      .to raise_error(Opal::Rails::MissingEntrypointError, /application\.rb/)
+  end
+
+  it 'resolves top-level ruby files when entrypoints is :all' do
+    @entrypoints_path.join('zeta.rb').write("puts 'zeta'\n")
+    @entrypoints_path.join('alpha.rb').write("puts 'alpha'\n")
+    FileUtils.mkdir_p(@entrypoints_path.join('nested'))
+    @entrypoints_path.join('nested/ignored.rb').write("puts 'ignored'\n")
+
+    resolver = described_class.new(
+      entrypoints_path: @entrypoints_path,
+      entrypoints: :all
+    )
+
+    expect(resolver.resolve).to eq(
+      'alpha' => 'alpha.rb',
+      'zeta' => 'zeta.rb'
+    )
+  end
+end

data/spec/opal/rails/haml_filter_spec.rb

@@ -0,0 +1,41 @@
+require 'open3'
+require 'rbconfig'
+require 'opal/rails/haml_filter'
+
+RSpec.describe 'Opal Haml filter loader' do
+  let(:project_root) { File.expand_path('../../..', __dir__) }
+
+  def run_loader_with_version(version)
+    script = <<~RUBY
+      require 'haml'
+      Haml.send(:remove_const, :VERSION)
+      Haml::VERSION = #{version.inspect}
+      require 'opal/rails/haml_filter'
+    RUBY
+
+    Open3.capture3('bundle', '_4.0.3_', 'exec', RbConfig.ruby, '-I', File.join(project_root, 'lib'), '-e', script,
+                   chdir: project_root)
+  end
+
+  it 'rejects Haml 5.x' do
+    _stdout, stderr, status = run_loader_with_version('5.2.2')
+
+    expect(status).not_to be_success
+    expect(stderr).to include('Haml 6 or newer')
+  end
+
+  it 'loads on Haml 6+' do
+    _stdout, _, status = run_loader_with_version('6.3.0')
+
+    expect(status).to be_success
+  end
+
+  it 'returns the module script mime type when ESM is enabled' do
+    original_esm = Opal::Config.esm
+    Opal::Config.esm = true
+
+    expect(Haml::Filters::Opal.allocate.mime_type).to eq('module')
+  ensure
+    Opal::Config.esm = original_esm
+  end
+end

data/spec/opal/rails/legacy_upgrade_warning_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe Opal::Rails::LegacyUpgradeWarning do
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @root = Pathname(dir)
+      FileUtils.mkdir_p(@root.join('config/initializers'))
+      FileUtils.mkdir_p(@root.join('app/assets/config'))
+      example.run
+    end
+  end
+
+  it 'warns for the reproduced 2.x generator layout' do
+    @root.join('config/initializers/opal.rb').write(<<~RUBY)
+      Rails.application.configure do
+        config.opal.method_missing_enabled = true
+        config.opal.const_missing_enabled = true
+        config.opal.arity_check_enabled = false
+        config.opal.freezing_stubs_enabled = true
+        config.opal.dynamic_require_severity = :warning
+        config.opal.assigns_in_templates = false
+      end
+    RUBY
+    @root.join('app/assets/config/manifest.js').write("//= link_directory ../javascript .js\n")
+    FileUtils.mkdir_p(@root.join('app/assets/javascript'))
+    @root.join('app/assets/javascript/application.js.rb').write("require 'opal'\n")
+
+    warning = described_class.warning_for(@root)
+
+    expect(warning).to include('likely 2.x application layout')
+    expect(warning).to include('Pin `opal-rails` to the 2.0 series')
+    expect(warning).to include('config.opal.suppress_legacy_upgrade_warning = true')
+    expect(warning).to include('config/initializers/opal.rb still uses legacy 2.x runtime settings')
+    expect(warning).to include('legacy Opal asset entrypoint present at app/assets/javascript/application.js.rb')
+    expect(warning).to include('app/assets/config/manifest.js still links the legacy javascript asset tree')
+    expect(warning).to include('expected 3.x source root app/opal is missing')
+  end
+
+  it 'does not warn for a build-based 3.x layout' do
+    @root.join('config/initializers/opal.rb').write(<<~RUBY)
+      Rails.application.configure do
+        config.opal.source_path = Rails.root.join('app/opal')
+        config.opal.entrypoints_path = config.opal.source_path
+        config.opal.build_path = Rails.root.join('app/assets/builds')
+        config.opal.entrypoints = { 'application' => 'application.rb' }
+      end
+    RUBY
+    FileUtils.mkdir_p(@root.join('app/opal'))
+
+    expect(described_class.warning_for(@root)).to be_nil
+  end
+
+  it 'does not warn from a single weak signal' do
+    @root.join('config/initializers/opal.rb').write(<<~RUBY)
+      Rails.application.configure do
+        config.opal.method_missing_enabled = true
+      end
+    RUBY
+
+    expect(described_class.warning_for(@root)).to be_nil
+  end
+
+  it 'writes the warning to the provided output' do
+    @root.join('config/initializers/opal.rb').write(<<~RUBY)
+      Rails.application.configure do
+        config.opal.method_missing_enabled = true
+        config.opal.const_missing_enabled = true
+      end
+    RUBY
+    @root.join('app/assets/config/manifest.js').write("//= link_directory ../javascript .js\n")
+
+    output = StringIO.new
+
+    expect(described_class.warn_if_needed(Struct.new(:root).new(@root), output: output)).to be(true)
+    expect(output.string).to include('likely 2.x application layout')
+  end
+
+  it 'does not write the warning when suppression is enabled' do
+    @root.join('config/initializers/opal.rb').write(<<~RUBY)
+      Rails.application.configure do
+        config.opal.method_missing_enabled = true
+        config.opal.const_missing_enabled = true
+      end
+    RUBY
+    @root.join('app/assets/config/manifest.js').write("//= link_directory ../javascript .js\n")
+
+    output = StringIO.new
+    app = Struct.new(:root, :config).new(@root,
+                                         Struct.new(:opal).new(Struct.new(:suppress_legacy_upgrade_warning).new(true)))
+
+    expect(described_class.warn_if_needed(app, output: output)).to be(false)
+    expect(output.string).to be_empty
+  end
+end

data/spec/opal/rails/outputs_manifest_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe Opal::Rails::OutputsManifest do
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @build_path = Pathname(dir)
+      FileUtils.mkdir_p(@build_path)
+      example.run
+    end
+  end
+
+  it 'prunes only previously tracked outputs' do
+    @build_path.join('application.js').write('old')
+    @build_path.join('application.js.map').write('old map')
+    @build_path.join('unrelated.js').write('keep me')
+
+    manifest = described_class.new(build_path: @build_path)
+    manifest.write!(%w[application.js application.js.map])
+
+    manifest.prune_stale!(['application.js'])
+    manifest.write!(['application.js'])
+
+    expect(@build_path.join('application.js')).to exist
+    expect(@build_path.join('application.js.map')).not_to exist
+    expect(@build_path.join('unrelated.js')).to exist
+  end
+
+  it 'ignores paths that escape the build directory' do
+    outside_file = @build_path.join('..', 'outside.txt')
+    outside_file.write('should survive')
+
+    manifest = described_class.new(build_path: @build_path)
+    manifest.write!(['../outside.txt', 'application.js'])
+
+    @build_path.join('application.js').write('app')
+
+    manifest.prune_stale!(['application.js'])
+
+    expect(outside_file).to exist
+    expect(@build_path.join('application.js')).to exist
+  end
+end

data/spec/opal/rails/path_setup_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+RSpec.describe Opal::Rails::PathSetup do
+  FakeAssetsConfig = Struct.new(:excluded_paths)
+  FakeConfig = Struct.new(:opal, :eager_load_paths, :assets)
+  FakeApp = Struct.new(:root, :config)
+
+  class FakeAutoloader
+    attr_reader :ignored_paths
+
+    def initialize
+      @ignored_paths = []
+    end
+
+    def ignore(path)
+      @ignored_paths << path
+    end
+  end
+
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @root = Pathname(dir)
+      FileUtils.mkdir_p(@root.join('app/assets/opal'))
+      FileUtils.mkdir_p(@root.join('app/views'))
+      FileUtils.mkdir_p(@root.join('app/models'))
+      example.run
+    end
+  end
+
+  it 'defaults to app/opal and ignores it in autoloaders' do
+    config = FakeConfig.new(ActiveSupport::OrderedOptions.new, [
+                              @root.join('app/assets').to_s,
+                              @root.join('app/views').to_s,
+                              @root.join('app/opal').to_s,
+                              @root.join('app/models').to_s
+                            ], FakeAssetsConfig.new([]))
+
+    app = FakeApp.new(@root, config)
+    autoloaders = [FakeAutoloader.new, FakeAutoloader.new]
+
+    described_class.apply!(app, autoloaders: autoloaders)
+
+    expect(config.opal.source_path).to eq(@root.join('app/opal'))
+    expect(config.opal.entrypoints_path).to eq(@root.join('app/opal'))
+    expect(config.opal.build_path).to eq(@root.join('app/assets/builds'))
+    expect(config.eager_load_paths).to eq([
+                                            @root.join('app/models').to_s
+                                          ])
+    expect(autoloaders.map(&:ignored_paths)).to all(include(@root.join('app/opal')))
+    expect(config.assets.excluded_paths).to be_empty
+  end
+
+  it 'leaves app/assets/opal visible to the asset pipeline without autoloader ignores' do
+    config = FakeConfig.new(ActiveSupport::OrderedOptions.new, [
+                              @root.join('app/assets').to_s,
+                              @root.join('app/views').to_s,
+                              @root.join('app/models').to_s
+                            ], FakeAssetsConfig.new([]))
+    config.opal.source_path = @root.join('app/assets/opal')
+
+    app = FakeApp.new(@root, config)
+    autoloaders = [FakeAutoloader.new]
+
+    2.times { described_class.apply!(app, autoloaders: autoloaders) }
+
+    expect(config.opal.entrypoints_path).to eq(@root.join('app/assets/opal'))
+    expect(config.opal.build_path).to eq(@root.join('app/assets/builds'))
+    expect(config.assets.excluded_paths).to be_empty
+    expect(autoloaders.first.ignored_paths).to be_empty
+  end
+end

data/spec/opal/rails/task_hooks_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'rake'
+
+RSpec.describe Opal::Rails::TaskHooks do
+  let(:rake_application) { Rake::Application.new }
+
+  before do
+    Rake.application = rake_application
+    rake_application.define_task(Rake::Task, 'opal:build')
+    rake_application.define_task(Rake::Task, 'opal:clobber')
+  end
+
+  after do
+    Rake.application = nil
+  end
+
+  it 'attaches opal:build to known hook tasks when they exist' do
+    rake_application.define_task(Rake::Task, 'assets:precompile')
+    rake_application.define_task(Rake::Task, 'test:prepare')
+
+    described_class.apply!(task_manager: Rake::Task)
+
+    expect(Rake::Task['assets:precompile'].prerequisites).to include('opal:build')
+    expect(Rake::Task['test:prepare'].prerequisites).to include('opal:build')
+  end
+
+  it 'does not duplicate prerequisites when applied more than once' do
+    rake_application.define_task(Rake::Task, 'assets:precompile')
+
+    2.times { described_class.apply!(task_manager: Rake::Task) }
+
+    expect(Rake::Task['assets:precompile'].prerequisites.count('opal:build')).to eq(1)
+  end
+
+  it 'allows later task definitions to be hooked by reapplying' do
+    described_class.apply!(task_manager: Rake::Task)
+    rake_application.define_task(Rake::Task, 'spec:prepare')
+
+    described_class.apply!(task_manager: Rake::Task)
+
+    expect(Rake::Task['spec:prepare'].prerequisites).to include('opal:build')
+  end
+
+  it 'attaches opal:clobber to assets:clobber when it exists' do
+    rake_application.define_task(Rake::Task, 'assets:clobber')
+
+    described_class.apply!(task_manager: Rake::Task)
+
+    expect(Rake::Task['assets:clobber'].prerequisites).to include('opal:clobber')
+  end
+
+  it 'attaches test:prepare to the test task so rake test triggers opal:build' do
+    rake_application.define_task(Rake::Task, 'test')
+    rake_application.define_task(Rake::Task, 'test:prepare')
+
+    described_class.apply!(task_manager: Rake::Task)
+
+    expect(Rake::Task['test'].prerequisites).to include('test:prepare')
+    expect(Rake::Task['test:prepare'].prerequisites).to include('opal:build')
+  end
+end