Class ClientTest < ActionCable::TestCase

# File actioncable/test/client_test.rb, line 165
def faye_client(port)
  SyncClient.new(port)
end

# File actioncable/test/client_test.rb, line 37
def setup
  ActionCable.instance_variable_set(:@server, nil)
  server = ActionCable.server
  server.config.logger = Logger.new(StringIO.new).tap { |l| l.level = Logger::UNKNOWN }

  server.config.cable = { adapter: 'async' }.with_indifferent_access
  server.config.use_faye = ENV['FAYE'].present?

  # and now the "real" setup for our test:
  server.config.disable_request_forgery_protection = true

  Thread.new { EventMachine.run } unless EventMachine.reactor_running?
  Thread.pass until EventMachine.reactor_running?

  # faye-websocket is warning-rich
  @previous_verbose, $VERBOSE = $VERBOSE, nil
end

# File actioncable/test/client_test.rb, line 55
def teardown
  $VERBOSE = @previous_verbose
end

# File actioncable/test/client_test.rb, line 220
def test_disappearing_client
  with_puma_server do |port|
    c = faye_client(port)
    assert_equal({"type" => "welcome"}, c.read_message)  # pop the first welcome message off the stack
    c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "type"=>"confirm_subscription"}, c.read_message)
    c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'delay', message: 'hello')
    c.close # disappear before write

    c = faye_client(port)
    assert_equal({"type" => "welcome"}, c.read_message) # pop the first welcome message off the stack
    c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "type"=>"confirm_subscription"}, c.read_message)
    c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'ding', message: 'hello')
    assert_equal({"identifier"=>'{"channel":"ClientTest::EchoChannel"}', "message"=>{"dong"=>"hello"}}, c.read_message)
    c.close # disappear before read
  end
end

# File actioncable/test/client_test.rb, line 181
def test_interacting_clients
  with_puma_server do |port|
    clients = 10.times.map { faye_client(port) }

    barrier_1 = Concurrent::CyclicBarrier.new(clients.size)
    barrier_2 = Concurrent::CyclicBarrier.new(clients.size)

    clients.map {|c| Concurrent::Future.execute {
      assert_equal({"type" => "welcome"}, c.read_message)  # pop the first welcome message off the stack
      c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
      assert_equal({"identifier"=>'{"channel":"ClientTest::EchoChannel"}', "type"=>"confirm_subscription"}, c.read_message)
      c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'ding', message: 'hello')
      assert_equal({"identifier"=>'{"channel":"ClientTest::EchoChannel"}', "message"=>{"dong"=>"hello"}}, c.read_message)
      barrier_1.wait WAIT_WHEN_EXPECTING_EVENT
      c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'bulk', message: 'hello')
      barrier_2.wait WAIT_WHEN_EXPECTING_EVENT
      assert_equal clients.size, c.read_messages(clients.size).size
    } }.each(&:wait!)

    clients.map {|c| Concurrent::Future.execute { c.close } }.each(&:wait!)
  end
end

# File actioncable/test/client_test.rb, line 204
def test_many_clients
  with_puma_server do |port|
    clients = 100.times.map { faye_client(port) }

    clients.map {|c| Concurrent::Future.execute {
      assert_equal({"type" => "welcome"}, c.read_message)  # pop the first welcome message off the stack
      c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
      assert_equal({"identifier"=>'{"channel":"ClientTest::EchoChannel"}', "type"=>"confirm_subscription"}, c.read_message)
      c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'ding', message: 'hello')
      assert_equal({"identifier"=>'{"channel":"ClientTest::EchoChannel"}', "message"=>{"dong"=>"hello"}}, c.read_message)
    } }.each(&:wait!)

    clients.map {|c| Concurrent::Future.execute { c.close } }.each(&:wait!)
  end
end

# File actioncable/test/client_test.rb, line 263
def test_server_restart
  with_puma_server do |port|
    c = faye_client(port)
    assert_equal({"type" => "welcome"}, c.read_message)
    c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "type"=>"confirm_subscription"}, c.read_message)

    ActionCable.server.restart
    c.wait_for_close
    assert c.closed?
  end
end

# File actioncable/test/client_test.rb, line 169
def test_single_client
  with_puma_server do |port|
    c = faye_client(port)
    assert_equal({"type" => "welcome"}, c.read_message)  # pop the first welcome message off the stack
    c.send_message command: 'subscribe', identifier: JSON.generate(channel: 'ClientTest::EchoChannel')
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "type"=>"confirm_subscription"}, c.read_message)
    c.send_message command: 'message', identifier: JSON.generate(channel: 'ClientTest::EchoChannel'), data: JSON.generate(action: 'ding', message: 'hello')
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "message"=>{"dong"=>"hello"}}, c.read_message)
    c.close
  end
end

# File actioncable/test/client_test.rb, line 239
def test_unsubscribe_client
  with_puma_server do |port|
    app = ActionCable.server
    identifier = JSON.generate(channel: 'ClientTest::EchoChannel')

    c = faye_client(port)
    assert_equal({"type" => "welcome"}, c.read_message)
    c.send_message command: 'subscribe', identifier: identifier
    assert_equal({"identifier"=>"{\"channel\":\"ClientTest::EchoChannel\"}", "type"=>"confirm_subscription"}, c.read_message)
    assert_equal(1, app.connections.count)
    assert(app.remote_connections.where(identifier: identifier))

    subscriptions = app.connections.first.subscriptions.send(:subscriptions)
    assert_not_equal 0, subscriptions.size, 'Missing EchoChannel subscription'
    channel = subscriptions.first[1]
    channel.expects(:unsubscribed)
    c.close
    sleep 0.1 # Data takes a moment to process

    # All data is removed: No more connection or subscription information!
    assert_equal(0, app.connections.count)
  end
end

# File actioncable/test/client_test.rb, line 59
def with_puma_server(rack_app = ActionCable.server, port = 3099)
  server = ::Puma::Server.new(rack_app, ::Puma::Events.strings)
  server.add_tcp_listener '127.0.0.1', port
  server.min_threads = 1
  server.max_threads = 4

  t = Thread.new { server.run.join }
  yield port

ensure
  server.stop(true) if server
  t.join if t
end