jam-cloud/spec/jam_websockets/router_spec.rb

require 'spec_helper'
require 'thread'

LoginClient = Class.new do
  attr_accessor :onmsgblock, :onopenblock, :encode_json, :client_id

  def initialize()

  end

  def onopen(&block)
    @onopenblock = block
  end

  def onmessage(&block)
    @onmsgblock = block
  end

  def close(&block)
    @oncloseblock = block
  end

  def close_websocket()
    
  end

  def send(msg)
    puts msg
  end

  def get_peername
    return "\x00\x02\x93\v\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00" # 37643, "localhost" 
  end

end


# does a login and returns client
def login(router, user, password)

  message_factory = MessageFactory.new
  client = LoginClient.new

  login_ack = message_factory.login_ack("127.0.0.1")

  router.should_receive(:send_to_client).with(client, login_ack)
  client.should_receive(:onclose)
  client.should_receive(:onerror)
  client.should_receive(:request).and_return({ "query" => { "pb" => "true" } })
  client.should_receive(:get_peername).and_return("\x00\x02\x93\v\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00")

  @router.new_client(client)
  client.onopenblock.call

  # create a login message, and pass it into the router via onmsgblock.call
  login = message_factory.login_with_user_pass(user.email, password)

  # first log in
  client.onmsgblock.call login.to_s

  # then join music session
  return client
end


def login_music_session(router, client, music_session)
  message_factory = MessageFactory.new
  login_music_session = message_factory.login_music_session(music_session.id)
  login_ack = message_factory.login_music_session_ack(false, nil);
  router.should_receive(:send_to_client).with(client, login_ack)
  client.onmsgblock.call login_music_session.to_s
end


describe Router do

  message_factory = MessageFactory.new

  before do

    @router = Router.new()
    @router.start()

  end

  subject { @router }

  after do
    @router.stop
  end


  describe "servicability" do
    it "should start and stop", :mq => true do
    end

    it "should register for client events", :mq => true do
      client = double("client")
      client.should_receive(:onopen)
      client.should_receive(:onclose)
      client.should_receive(:onerror)
      client.should_receive(:onmessage)
      client.should_receive(:encode_json=)
      client.should_receive(:client_id=)

      @router.new_client(client)

    end
  end

  describe "topic routing helpers" do
    it "create and delete user lookup set" do
      user = double(User)
      user.should_receive(:id).any_number_of_times.and_return("1")
      client = double("client")
      context = ClientContext.new(user, client)

      @router.user_context_lookup.length.should == 0

      @router.add_user(context)
  
      @router.user_context_lookup.length.should == 1

      @router.remove_user(context)

      @router.user_context_lookup.length.should == 0
    end
  end


  describe "login" do
    it "should not allow login of bogus user", :mq => true do
      TestClient = Class.new do

        attr_accessor :onmsgblock, :onopenblock, :encode_json, :client_id

        def initialize()

        end

        def onopen(&block)
          @onopenblock = block
        end

        def onmessage(&block)
          @onmsgblock = block
        end

        def close_websocket() 
        end

        def close()
        end
      end

      client = TestClient.new

      error_msg = message_factory.server_rejection_error("invalid login")

      @router.should_receive(:send_to_client).with(client, error_msg)
      client.should_receive(:close_websocket)
      client.should_receive(:onclose)
      client.should_receive(:onerror)
      client.should_receive(:request).and_return({ "query" => { "pb" => "true" } })


      @router.new_client(client)
      client.onopenblock.call

      # create a login message, and pass it into the router via onmsgblock.call
      login = message_factory.login_with_user_pass("baduser@example.com", "foobar")

      client.onmsgblock.call login.to_s

    end

    it "should allow login of valid user", :mq => true do
      @user = User.new(:name => "Example User", :email => "user@example.com",
                       :password => "foobar", :password_confirmation => "foobar")
      @user.save

      puts "USER ID = #{@user.id}"

      client1 = login(@router, @user, "foobar")
    end

    it "should allow music_session_join of valid user", :mq => true do

      user1 = FactoryGirl.create(:user) # in the music session
      user2 = FactoryGirl.create(:user) # in the music session
      user3 = FactoryGirl.create(:user) # not in the music session

      music_session = FactoryGirl.create(:music_session, :creator => user1)

      music_session_member1 = FactoryGirl.create(:music_session_client, :user => user1, :music_session => music_session)
      music_session_member2 = FactoryGirl.create(:music_session_client, :user => user2, :music_session => music_session)

      # make a music_session and define two members

      # create client 1, log him in, and log him in to music session
      client1 = login(@router, user1, "foobar")
      login_music_session(@router, client1, music_session)
    end

    it "should allow two valid subscribers to communicate with session-directed messages", :mq => true do

      EventMachine.run do
        user1 = FactoryGirl.create(:user) # in the music session
        user2 = FactoryGirl.create(:user) # in the music session

        music_session = FactoryGirl.create(:music_session, :creator => user1)

        music_session_member1 = FactoryGirl.create(:music_session_client, :user => user1, :music_session => music_session)
        music_session_member2 = FactoryGirl.create(:music_session_client, :user => user2, :music_session => music_session)

        # make a music_session and define two members


        # create client 1, log him in, and log him in to music session
        client1 = login(@router, user1, "foobar")
        login_music_session(@router, client1, music_session)

        client2 = login(@router, user2, "foobar")
        login_music_session(@router, client2, music_session)
        EM.stop
      end
    end
  end
end