cable_ready 4.4.6 → 5.0.0.pre2

data/tags

@@ -9,49 +9,72 @@ CableReady	lib/cable_ready.rb	/^module CableReady$/;"	m
 CableReady	lib/cable_ready/broadcaster.rb	/^module CableReady$/;"	m
 CableReady	lib/cable_ready/channel.rb	/^module CableReady$/;"	m
 CableReady	lib/cable_ready/channels.rb	/^module CableReady$/;"	m
+CableReady	lib/cable_ready/config.rb	/^module CableReady$/;"	m
 CableReady	lib/cable_ready/version.rb	/^module CableReady$/;"	m
+CableReady	lib/generators/cable_ready/channel_generator.rb	/^class CableReady::ChannelGenerator < Rails::Generators::NamedBase$/;"	c
+CableReady	test/lib/generators/cable_ready/channel_generator_test.rb	/^class CableReady::ChannelGeneratorTest < Rails::Generators::TestCase$/;"	c
 Channel	lib/cable_ready/channel.rb	/^  class Channel$/;"	c	class:CableReady
 Channels	lib/cable_ready/channels.rb	/^  class Channels$/;"	c	class:CableReady
+ClassMethods	test/support/generator_test_helpers.rb	/^  module ClassMethods$/;"	m	class:GeneratorTestHelpers
+Config	lib/cable_ready/config.rb	/^  class Config$/;"	c	class:CableReady
 Engine	lib/cable_ready.rb	/^  class Engine < Rails::Engine$/;"	c	class:CableReady
+GeneratorTestHelpers	test/support/generator_test_helpers.rb	/^module GeneratorTestHelpers$/;"	m
 []	lib/cable_ready/channels.rb	/^    def [](identifier)$/;"	f	class:CableReady.Channels
-add_operation	lib/cable_ready/channels.rb	/^    def add_operation(operation, &implementation)$/;"	f	class:CableReady.Channels
-broadcast	lib/cable_ready/channel.rb	/^    def broadcast(clear = true)$/;"	f	class:CableReady.Channel
+add_operation_method	lib/cable_ready/channel.rb	/^    def add_operation_method(name)$/;"	f	class:CableReady.Channel
+add_operation_name	lib/cable_ready/config.rb	/^    def add_operation_name(name)$/;"	f	class:CableReady.Config
+broadcast	lib/cable_ready/channel.rb	/^    def broadcast(clear: true)$/;"	f	class:CableReady.Channel
 broadcast	lib/cable_ready/channels.rb	/^    def broadcast(*identifiers, clear: true)$/;"	f	class:CableReady.Channels
-broadcast_to	lib/cable_ready/channel.rb	/^    def broadcast_to(model, clear = true)$/;"	f	class:CableReady.Channel
+broadcast_to	lib/cable_ready/channel.rb	/^    def broadcast_to(model, clear: true)$/;"	f	class:CableReady.Channel
 broadcast_to	lib/cable_ready/channels.rb	/^    def broadcast_to(model, *identifiers, clear: true)$/;"	f	class:CableReady.Channels
+broadcastable_operations	lib/cable_ready/channel.rb	/^    def broadcastable_operations$/;"	f	class:CableReady.Channel
 cable_ready	lib/cable_ready/broadcaster.rb	/^    def cable_ready$/;"	f	class:CableReady.Broadcaster
-channel_broadcast	lib/cable_ready/channel.rb	/^    def channel_broadcast(clear)$/;"	f	class:CableReady.Channel
-channel_broadcast_to	lib/cable_ready/channel.rb	/^    def channel_broadcast_to(model, clear)$/;"	f	class:CableReady.Channel
-configure	lib/cable_ready/channels.rb	/^    def self.configure$/;"	F	class:CableReady.Channels
-const.bubbles	javascript/cable_ready.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
-const.cancelable	javascript/cable_ready.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
-const.color	javascript/cable_ready.js	/^  color: true,$/;"	p
-const.date	javascript/cable_ready.js	/^  date: true,$/;"	p
-const.datetime	javascript/cable_ready.js	/^  datetime: true,$/;"	p
-const.datetime-local	javascript/cable_ready.js	/^  'datetime-local': true,$/;"	p
-const.detail	javascript/cable_ready.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
-const.email	javascript/cable_ready.js	/^  email: true,$/;"	p
-const.month	javascript/cable_ready.js	/^  month: true,$/;"	p
-const.number	javascript/cable_ready.js	/^  number: true,$/;"	p
-const.password	javascript/cable_ready.js	/^  password: true,$/;"	p
-const.pushState	javascript/cable_ready.js	/^  pushState: config => {$/;"	p
-const.range	javascript/cable_ready.js	/^  range: true,$/;"	p
-const.search	javascript/cable_ready.js	/^  search: true,$/;"	p
-const.select-multiple	javascript/cable_ready.js	/^  'select-multiple': true,$/;"	p
-const.select-one	javascript/cable_ready.js	/^  'select-one': true,$/;"	p
-const.tel	javascript/cable_ready.js	/^  tel: true,$/;"	p
-const.text	javascript/cable_ready.js	/^  text: true,$/;"	p
-const.textarea	javascript/cable_ready.js	/^  textarea: true,$/;"	p
-const.time	javascript/cable_ready.js	/^  time: true,$/;"	p
-const.url	javascript/cable_ready.js	/^  url: true,$/;"	p
-const.value	javascript/cable_ready.js	/^    const ignore = { value: true }$/;"	p
-const.week	javascript/cable_ready.js	/^  week: true$/;"	p
+check_options	lib/generators/cable_ready/channel_generator.rb	/^  def check_options$/;"	f	class:CableReady
+config	lib/cable_ready.rb	/^  def self.config$/;"	F	class:CableReady
+configure	lib/cable_ready.rb	/^  def self.configure$/;"	F	class:CableReady
+const.bubbles	javascript/utils.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
+const.cancelable	javascript/utils.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
+const.detail	javascript/utils.js	/^  const init = { bubbles: true, cancelable: true, detail: detail }$/;"	p
+const.value	javascript/morph_callbacks.js	/^    const ignore = { value: true }$/;"	p
+create_channel	lib/generators/cable_ready/channel_generator.rb	/^  def create_channel$/;"	f	class:CableReady
+create_sample_app	test/support/generator_test_helpers.rb	/^    def create_sample_app$/;"	f	class:GeneratorTestHelpers.ClassMethods
+default_operation_names	lib/cable_ready/config.rb	/^    def default_operation_names$/;"	f	class:CableReady.Config
 dom_id	lib/cable_ready/broadcaster.rb	/^    def dom_id(record, prefix = nil)$/;"	f	class:CableReady.Broadcaster
-enqueue_operation	lib/cable_ready/channel.rb	/^    def enqueue_operation(key, options)$/;"	f	class:CableReady.Channel
-import.INPUT	javascript/cable_ready.js	/^  INPUT: true,$/;"	p
-import.SELECT	javascript/cable_ready.js	/^  SELECT: true$/;"	p
-import.TEXTAREA	javascript/cable_ready.js	/^  TEXTAREA: true,$/;"	p
-initialize	lib/cable_ready/channel.rb	/^    def initialize(identifier, available_operations)$/;"	f	class:CableReady.Channel
+enhance_channels	lib/generators/cable_ready/channel_generator.rb	/^  def enhance_channels$/;"	f	class:CableReady
+export.INPUT	javascript/enums.js	/^  INPUT: true,$/;"	p
+export.OPTION	javascript/enums.js	/^  OPTION: true$/;"	p
+export.SELECT	javascript/enums.js	/^  SELECT: true$/;"	p
+export.TEXTAREA	javascript/enums.js	/^  TEXTAREA: true,$/;"	p
+export.color	javascript/enums.js	/^  color: true,$/;"	p
+export.date	javascript/enums.js	/^  date: true,$/;"	p
+export.datetime	javascript/enums.js	/^  datetime: true,$/;"	p
+export.datetime-local	javascript/enums.js	/^  'datetime-local': true,$/;"	p
+export.email	javascript/enums.js	/^  email: true,$/;"	p
+export.month	javascript/enums.js	/^  month: true,$/;"	p
+export.number	javascript/enums.js	/^  number: true,$/;"	p
+export.password	javascript/enums.js	/^  password: true,$/;"	p
+export.range	javascript/enums.js	/^  range: true,$/;"	p
+export.search	javascript/enums.js	/^  search: true,$/;"	p
+export.select-multiple	javascript/enums.js	/^  'select-multiple': true,$/;"	p
+export.select-one	javascript/enums.js	/^  'select-one': true,$/;"	p
+export.tel	javascript/enums.js	/^  tel: true,$/;"	p
+export.text	javascript/enums.js	/^  text: true,$/;"	p
+export.textarea	javascript/enums.js	/^  textarea: true,$/;"	p
+export.time	javascript/enums.js	/^  time: true,$/;"	p
+export.url	javascript/enums.js	/^  url: true,$/;"	p
+export.week	javascript/enums.js	/^  week: true$/;"	p
+finalizer_for	lib/cable_ready/channel.rb	/^    def self.finalizer_for(identifier)$/;"	F	class:CableReady.Channel
+identifier	lib/generators/cable_ready/channel_generator.rb	/^  def identifier$/;"	f	class:CableReady
+included	test/support/generator_test_helpers.rb	/^  def self.included(base)$/;"	F	class:GeneratorTestHelpers
+initialize	lib/cable_ready/channel.rb	/^    def initialize(identifier)$/;"	f	class:CableReady.Channel
 initialize	lib/cable_ready/channels.rb	/^    def initialize$/;"	f	class:CableReady.Channels
-mutex	lib/cable_ready/channels.rb	/^    def mutex$/;"	f	class:CableReady.Channels
+initialize	lib/cable_ready/config.rb	/^    def initialize$/;"	f	class:CableReady.Config
+observers	lib/cable_ready/config.rb	/^    def observers$/;"	f	class:CableReady.Config
+operation_names	lib/cable_ready/config.rb	/^    def operation_names$/;"	f	class:CableReady.Config
+option_given?	lib/generators/cable_ready/channel_generator.rb	/^  def option_given?$/;"	f	class:CableReady
+prepare_destination	test/support/generator_test_helpers.rb	/^    def prepare_destination$/;"	f	class:GeneratorTestHelpers.ClassMethods
+remove_sample_app	test/support/generator_test_helpers.rb	/^    def remove_sample_app$/;"	f	class:GeneratorTestHelpers.ClassMethods
 reset	lib/cable_ready/channel.rb	/^    def reset$/;"	f	class:CableReady.Channel
+resource	lib/generators/cable_ready/channel_generator.rb	/^  def resource$/;"	f	class:CableReady
+sample_app_path	test/support/generator_test_helpers.rb	/^    def sample_app_path$/;"	f	class:GeneratorTestHelpers.ClassMethods
+using_broadcast_to?	lib/generators/cable_ready/channel_generator.rb	/^  def using_broadcast_to?$/;"	f	class:CableReady
+using_stimulus?	lib/generators/cable_ready/channel_generator.rb	/^  def using_stimulus?$/;"	f	class:CableReady

data/test/lib/cable_ready/cable_car_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "../../../lib/cable_ready"
+
+class CableReady::CableCarTest < ActiveSupport::TestCase
+  setup do
+    @cable_car = CableReady::CableCar.instance
+  end
+
+  test "dispatch should return json-ifiable payload" do
+    CableReady::CableCar.instance.reset!
+    dispatch = CableReady::CableCar.instance.inner_html(selector: "#users", html: "<span>winning</span>").dispatch
+    assert_equal({"innerHtml" => [{"selector" => "#users", "html" => "<span>winning</span>"}]}, dispatch)
+  end
+
+  test "dispatch should clear operations" do
+    CableReady::CableCar.instance.reset!
+    CableReady::CableCar.instance.inner_html(selector: "#users", html: "<span>winning</span>").dispatch
+    assert_equal({}, CableReady::CableCar.instance.instance_variable_get(:@enqueued_operations))
+  end
+
+  test "dispatch should maintain operations if clear is false" do
+    CableReady::CableCar.instance.reset!
+    CableReady::CableCar.instance.inner_html(selector: "#users", html: "<span>winning</span>").dispatch(clear: false)
+    assert_equal({"inner_html" => [{"selector" => "#users", "html" => "<span>winning</span>"}]}, CableReady::CableCar.instance.instance_variable_get(:@enqueued_operations))
+  end
+
+  test "selectors should accept any object which respond_to? to_dom_selector" do
+    CableReady::CableCar.instance.reset!
+    my_object = Struct.new(:id) do
+      def to_dom_selector
+        ".#{id}"
+      end
+    end.new("users")
+    dispatch = CableReady::CableCar.instance.inner_html(selector: my_object, html: "<span>winning</span>").dispatch
+    assert_equal({"innerHtml" => [{"selector" => ".users", "html" => "<span>winning</span>"}]}, dispatch)
+  end
+
+  test "selectors should accept any object which respond_to? to_dom_id" do
+    CableReady::CableCar.instance.reset!
+    my_object = Struct.new(:id) do
+      def to_dom_id
+        id
+      end
+    end.new("users")
+    dispatch = CableReady::CableCar.instance.inner_html(selector: my_object, html: "<span>winning</span>").dispatch
+    assert_equal({"innerHtml" => [{"selector" => "#users", "html" => "<span>winning</span>"}]}, dispatch)
+  end
+end

data/test/lib/cable_ready/identifiable_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "../../../lib/cable_ready"
+
+class User
+  include ActiveModel::Model
+
+  attr_accessor :id
+end
+
+class CableReady::IdentifiableTest < ActiveSupport::TestCase
+  include CableReady::Identifiable
+
+  test "should handle nil" do
+    assert_equal "#", dom_id(nil)
+  end
+
+  test "should work with strings" do
+    assert_equal "#users", dom_id("users")
+    assert_equal "#users", dom_id("users  ")
+    assert_equal "#users", dom_id("  users  ")
+  end
+
+  test "should work with symbols" do
+    assert_equal "#users", dom_id(:users)
+    assert_equal "#active_users", dom_id(:active_users)
+  end
+
+  test "should just return one hash" do
+    assert_equal "#users", dom_id("users")
+    assert_equal "#users", dom_id("#users")
+    assert_equal "#users", dom_id("##users")
+  end
+
+  test "should strip prefixes" do
+    assert_equal "#active_users", dom_id("  users ", "     active    ")
+    assert_equal "#all_active_users", dom_id(" users  ", "  all_active ")
+  end
+
+  test "should not include provided prefix if prefix is nil" do
+    assert_equal "#users", dom_id("users", nil)
+  end
+
+  test "should work with ActiveRecord::Relation" do
+    relation = mock("ActiveRecord::Relation")
+
+    relation.stubs(:is_a?).with(ActiveRecord::Relation).returns(true).at_least_once
+    relation.stubs(:is_a?).with(ActiveRecord::Base).never
+    relation.stubs(:model_name).returns(OpenStruct.new(plural: "users"))
+
+    assert_equal "#users", dom_id(relation)
+    assert_equal "#users", dom_id(relation, nil)
+    assert_equal "#active_users", dom_id(relation, "active")
+  end
+
+  test "should work with ActiveRecord::Base" do
+    User.any_instance.stubs(:is_a?).with(ActiveRecord::Relation).returns(false)
+    User.any_instance.stubs(:is_a?).with(ActiveRecord::Base).returns(true)
+
+    assert_equal "#new_user", dom_id(User.new(id: nil))
+
+    user = User.new(id: 42)
+
+    assert_equal "#user_42", dom_id(user)
+    assert_equal "#user_42", dom_id(user, nil)
+    assert_equal "#all_active_user_42", dom_id(user, "all_active")
+
+    user = User.new(id: 99)
+
+    assert_equal "#user_99", dom_id(user)
+    assert_equal "#user_99", dom_id(user, nil)
+    assert_equal "#all_active_user_99", dom_id(user, "all_active")
+  end
+end

data/test/lib/cable_ready/operation_builder_test.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "../../../lib/cable_ready"
+
+class Death
+  def to_html
+    "I rock"
+  end
+
+  def to_dom_id
+    "death"
+  end
+
+  def to_operation_options
+    [:html, :dom_id, :spaz]
+  end
+end
+
+class Life
+  def to_operation_options
+    {
+      html: "You go, girl",
+      dom_id: "life"
+    }
+  end
+end
+
+class CableReady::OperationBuilderTest < ActiveSupport::TestCase
+  setup do
+    @operation_builder = CableReady::OperationBuilder.new("test")
+  end
+
+  test "should create enqueued operations" do
+    assert_not_nil @operation_builder.instance_variable_get(:@enqueued_operations)
+  end
+
+  test "should add observer to cable ready" do
+    assert_not_nil CableReady.config.instance_variable_get(:@observer_peers)[@operation_builder]
+  end
+
+  test "should remove observer when destroyed" do
+    @operation_builder = nil
+    assert_nil CableReady.config.instance_variable_get(:@observer_peers)[@operation_builder]
+  end
+
+  test "should add operation method" do
+    @operation_builder.add_operation_method("foobar")
+    assert @operation_builder.respond_to?(:foobar)
+  end
+
+  test "added operation method should add keys" do
+    @operation_builder.add_operation_method("foobar")
+    @operation_builder.foobar({name: "passed_option"})
+
+    operations = @operation_builder.instance_variable_get(:@enqueued_operations)
+
+    assert_equal 1, operations["foobar"].size
+    assert_equal({"name" => "passed_option"}, operations["foobar"].first)
+  end
+
+  test "should json-ify operations" do
+    @operation_builder.add_operation_method("foobar")
+    @operation_builder.foobar({name: "passed_option"})
+    assert_equal("{\"foobar\":[{\"name\":\"passed_option\"}]}", @operation_builder.to_json)
+  end
+
+  test "should apply! many operations" do
+    @operation_builder.apply!(foobar: [{name: "passed_option"}])
+
+    operations = @operation_builder.instance_variable_get(:@enqueued_operations)
+    assert_equal 1, operations["foobar"].size
+    assert_equal({"name" => "passed_option"}, operations["foobar"].first)
+  end
+
+  test "should apply! many operations from a string" do
+    @operation_builder.apply!(JSON.generate({foobar: [{name: "passed_option"}]}))
+
+    operations = @operation_builder.instance_variable_get(:@enqueued_operations)
+    assert_equal 1, operations["foobar"].size
+    assert_equal({"name" => "passed_option"}, operations["foobar"].first)
+  end
+
+  test "operations payload should omit empty operations" do
+    @operation_builder.add_operation_method("foobar")
+    payload = @operation_builder.operations_payload
+    assert_equal({}, payload)
+  end
+
+  test "operations payload should camelize keys" do
+    @operation_builder.add_operation_method("foo_bar")
+    @operation_builder.foo_bar({beep_boop: "passed_option"})
+    assert_equal({"fooBar" => [{"beepBoop" => "passed_option"}]}, @operation_builder.operations_payload)
+  end
+
+  test "should take first argument as selector" do
+    @operation_builder.add_operation_method("inner_html")
+
+    @operation_builder.inner_html("#smelly", html: "<span>I rock</span>")
+
+    operations = {
+      "innerHtml" => [{"html" => "<span>I rock</span>", "selector" => "#smelly"}]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should use previously passed selector in next operation" do
+    @operation_builder.add_operation_method("inner_html")
+    @operation_builder.add_operation_method("set_focus")
+
+    @operation_builder.set_focus("#smelly").inner_html(html: "<span>I rock</span>")
+
+    operations = {
+      "setFocus" => [{"selector" => "#smelly"}],
+      "innerHtml" => [{"html" => "<span>I rock</span>", "selector" => "#smelly"}]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should clear previous_selector after calling reset!" do
+    @operation_builder.add_operation_method("inner_html")
+    @operation_builder.inner_html(selector: "#smelly", html: "<span>I rock</span>")
+
+    @operation_builder.reset!
+
+    @operation_builder.inner_html(html: "<span>winning</span>")
+
+    assert_equal({"innerHtml" => [{"html" => "<span>winning</span>"}]}, @operation_builder.operations_payload)
+  end
+
+  test "should use previous_selector if present and should use `selector` if explicitly provided" do
+    @operation_builder.add_operation_method("inner_html")
+    @operation_builder.add_operation_method("set_focus")
+
+    @operation_builder.set_focus("#smelly").inner_html(html: "<span>I rock</span>").inner_html(html: "<span>I rock too</span>", selector: "#smelly2")
+
+    operations = {
+      "setFocus" => [
+        {"selector" => "#smelly"}
+      ],
+      "innerHtml" => [
+        {"html" => "<span>I rock</span>", "selector" => "#smelly"},
+        {"html" => "<span>I rock too</span>", "selector" => "#smelly2"}
+      ]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should pull html option from Death object" do
+    @operation_builder.add_operation_method("inner_html")
+    death = Death.new
+
+    @operation_builder.inner_html(html: death)
+
+    operations = {
+      "innerHtml" => [
+        {"html" => "I rock"}
+      ]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should pull html option with selector from Death object" do
+    @operation_builder.add_operation_method("inner_html")
+    death = Death.new
+
+    @operation_builder.inner_html(death, html: death)
+
+    operations = {
+      "innerHtml" => [
+        {"html" => "I rock", "selector" => "#death"}
+      ]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should pull html and dom_id options from Death object" do
+    @operation_builder.add_operation_method("inner_html")
+    death = Death.new
+
+    @operation_builder.inner_html(death)
+
+    operations = {
+      "innerHtml" => [
+        {"html" => "I rock", "domId" => "death"}
+      ]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+
+  test "should pull html and dom_id options from Life object" do
+    @operation_builder.add_operation_method("inner_html")
+    life = Life.new
+
+    @operation_builder.inner_html(life)
+
+    operations = {
+      "innerHtml" => [
+        {"html" => "You go, girl", "domId" => "life"}
+      ]
+    }
+
+    assert_equal(operations, @operation_builder.operations_payload)
+  end
+end

data/test/lib/generators/cable_ready/channel_generator_test.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "generators/cable_ready/channel_generator"
+
+class CableReady::ChannelGeneratorTest < Rails::Generators::TestCase
+  include ::GeneratorTestHelpers
+
+  tests CableReady::ChannelGenerator
+  destination File.expand_path("../../../../tmp/dummy", __dir__)
+
+  prepare_destination
+  create_sample_app
+
+  MiniTest.after_run do
+    remove_sample_app
+  end
+
+  test "should generate channel with the same resource name and stimulus controller" do
+    run_generator ["user", "--stream-for=user", "--stimulus"]
+
+    assert_file "app/channels/user_channel.rb" do |content|
+      assert_match(/class\ UserChannel\ </, content)
+      assert_match(/stream_for\ User\.find\(params\[:id\]\)/, content)
+    end
+
+    assert_file "app/javascript/channels/user_channel.js", /"UserChannel"/
+    assert_file "app/javascript/controllers/user_controller.js", /'UserChannel'/
+  end
+
+  test "should generate channel with different resource name" do
+    run_generator ["my_name", "--stream-for=under_scored_resource_name", "--no-stimulus"]
+
+    assert_file "app/channels/my_name_channel.rb" do |content|
+      assert_match(/class\ MyNameChannel\ </, content)
+      assert_match(/stream_for\ UnderScoredResourceName\.find\(params\[:id\]\)/, content)
+    end
+
+    assert_file "app/javascript/channels/my_name_channel.js", /"MyNameChannel"/
+    assert_no_file "app/javascript/controllers/my_name_controller.js"
+  end
+
+  test "should not generate stimulus controller if not requested" do
+    run_generator ["comment", "--stream-for=comment", "--no-stimulus"]
+
+    assert_file "app/channels/comment_channel.rb"
+    assert_file "app/javascript/channels/comment_channel.js"
+    assert_no_file "app/javascript/controllers/comment_controller.js"
+  end
+
+  test "should run the generator when streaming from identifier" do
+    run_generator ["page", "--stream-from=page"]
+
+    assert_file "app/channels/page_channel.rb" do |content|
+      assert_match(/PageChannel/, content)
+      assert_match(/stream_from\ "page"/, content)
+    end
+
+    assert_file "app/javascript/channels/page_channel.js" do |content|
+      assert_match(/"PageChannel"/, content)
+      assert_match(/import\ CableReady/, content)
+      assert_match(/if\ \(data\.cableReady\)\ CableReady\.perform\(data\.operations\)/, content)
+    end
+  end
+
+  test "should run the generator when streaming without resource and different identifier" do
+    run_generator ["my_page", "--stream-from=ThisIsMyPage"]
+
+    assert_file "app/channels/my_page_channel.rb" do |content|
+      assert_match(/MyPageChannel/, content)
+      assert_match(/stream_from\ "this_is_my_page"/, content)
+    end
+
+    assert_file "app/javascript/channels/my_page_channel.js" do |content|
+      assert_match(/"MyPageChannel"/, content)
+      assert_match(/import\ CableReady/, content)
+      assert_match(/if\ \(data\.cableReady\)\ CableReady\.perform\(data\.operations\)/, content)
+    end
+  end
+
+  test "should run the generator and use the NAME for --stream-from if nothing passed" do
+    run_generator ["house", "--stream-from"]
+
+    assert_file "app/channels/house_channel.rb" do |content|
+      assert_match(/HouseChannel/, content)
+      assert_match(/stream_from\ "house"/, content)
+    end
+
+    assert_file "app/javascript/channels/house_channel.js" do |content|
+      assert_match(/"HouseChannel"/, content)
+      assert_match(/import\ CableReady/, content)
+      assert_match(/if\ \(data\.cableReady\)\ CableReady\.perform\(data\.operations\)/, content)
+    end
+  end
+
+  test "should run the generator and use the NAME for --stream-for if nothing passed" do
+    run_generator ["option", "--stream-for", "--stimulus"]
+
+    assert_file "app/channels/option_channel.rb" do |content|
+      assert_match(/class\ OptionChannel\ </, content)
+      assert_match(/stream_for\ Option\.find\(params\[:id\]\)/, content)
+    end
+
+    assert_file "app/javascript/channels/option_channel.js", /"OptionChannel"/
+    assert_file "app/javascript/controllers/option_controller.js", /'OptionChannel'/
+  end
+
+  test "should run not generate anything if passed stream_from and stream_for" do
+    assert_raises "Can't specify --stream-from and --stream-for at the same time" do
+      run_generator ["error", "--stream-from=1", "--stream-for=2"]
+    end
+  end
+
+  # some tests without generator options to simulate the inputs passed via cli
+
+  test "should generate channel with the same resource name and stimulus controller (without options)" do
+    CableReady::ChannelGenerator.any_instance.stubs(:using_broadcast_to?).returns(true)
+    CableReady::ChannelGenerator.any_instance.stubs(:resource).returns("Post")
+    CableReady::ChannelGenerator.any_instance.stubs(:using_stimulus?).returns(true)
+
+    run_generator ["post"]
+
+    assert_file "app/channels/post_channel.rb" do |content|
+      assert_match(/class\ PostChannel\ </, content)
+      assert_match(/stream_for\ Post\.find\(params\[:id\]\)/, content)
+    end
+
+    assert_file "app/javascript/channels/post_channel.js", /PostChannel/
+    assert_file "app/javascript/controllers/post_controller.js", /'PostChannel'/
+  end
+
+  test "should not generate stimulus controller if not requested (without options)" do
+    CableReady::ChannelGenerator.any_instance.stubs(:using_broadcast_to?).returns(true)
+    CableReady::ChannelGenerator.any_instance.stubs(:resource).returns("Admin")
+    CableReady::ChannelGenerator.any_instance.stubs(:using_stimulus?).returns(false)
+
+    run_generator ["admin"]
+
+    assert_file "app/channels/admin_channel.rb"
+    assert_file "app/javascript/channels/admin_channel.js"
+    assert_no_file "app/javascript/controllers/admin_controller.js"
+  end
+
+  test "should run the generator when streaming from identifier (without options)" do
+    CableReady::ChannelGenerator.any_instance.stubs(:using_broadcast_to?).returns(false)
+    CableReady::ChannelGenerator.any_instance.stubs(:identifier).returns("index_identifier")
+
+    run_generator ["index"]
+
+    assert_file "app/channels/index_channel.rb" do |content|
+      assert_match(/IndexChannel/, content)
+      assert_match(/stream_from\ "index_identifier"/, content)
+    end
+
+    assert_file "app/javascript/channels/index_channel.js", /"IndexChannel"/
+  end
+end