pepito 0.0.1

data/test/pepito/handler/test_http_router.rb

@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+require 'pepito/handler/http_router'
+
+class Stub
+  include Pepito::Handler::HTTPRouter
+end
+
+class TestPepitoHandlerHTTPRouter < MiniTest::Test
+  def test_emtpy_routes
+    stub = Stub.new
+    assert_empty stub.http_routes
+  end
+
+  def test_add_route
+    stub = Stub.new
+    stub.http_route('GET', '/path', :func_sym)
+
+    assert stub.http_routes[0]
+  end
+end

data/test/pepito/handlers/test_extensions_catalog.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'pepito/handlers/room'
+
+class TestPepitoHandlersExtensionsCatalog < MiniTest::Test
+  def setup
+    @handler = Pepito::Handlers::ExtensionsCatalog.new(nil)
+    @handler.run
+  end
+
+  def test_has_chat_routes
+    chat_routes = [
+      'handlers list',
+      'adapters list',
+      'routes list'
+    ]
+    @handler.chat_routes.each do |route|
+      chat_routes.entries.each do |r|
+        chat_routes.delete(r) if route.pattern.match(r)
+      end
+    end
+    assert_empty chat_routes
+  end
+
+  def test_has_web_routes
+    http_routes = [
+      { method: 'GET', path: '/extensions' },
+      { method: 'GET', path: '/handlers' },
+      { method: 'GET', path: '/adapters' },
+      { method: 'GET', path: '/routes' }
+    ]
+    @handler.http_routes.each do |route|
+      http_routes.entries.each do |r|
+        http_routes.delete(r) if route.route.path_for_generation == r[:path] && route.route.request_methods.include?(r[:method])
+      end
+    end
+    assert_empty http_routes
+  end
+end

data/test/pepito/handlers/test_help.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'pepito/handlers/room'
+
+class TestPepitoHandlersHelp < MiniTest::Test
+  Struct.new('Robot', :name, :handlers)
+  Struct.new('Route', :help, :command)
+  Struct.new('Handler', :chat_routes)
+
+  def setup
+    @mock_robot = Struct::Robot.new('pepito', [])
+    @handler = Pepito::Handlers::Help.new(@mock_robot)
+    @handler.run
+  end
+
+  def test_has_chat_routes
+    chat_routes = ['help']
+    @handler.chat_routes.each do |route|
+      chat_routes.entries.each do |r|
+        chat_routes.delete(r) if route.pattern.match(r)
+      end
+    end
+    assert_empty chat_routes
+  end
+
+  def test_chat_help
+    route_1 = Struct::Route.new('route1 help', false)
+    route_2 = Struct::Route.new('route2 help', true)
+
+    handler1 = Struct::Handler.new([route_1, route_2])
+    handler2 = Struct::Handler.new([route_1, route_2])
+
+    @mock_robot.handlers = { h1: handler1, h2: handler2 }
+
+    chat_help = @handler.chat_help(nil, nil)
+    expected = ['route1 help', 'pepito route2 help', 'route1 help', 'pepito route2 help']
+    assert chat_help, expected
+  end
+end

data/test/pepito/handlers/test_info.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'pepito/handlers/info'
+require 'pepito/version'
+
+class TestPepitoHandlersInfo < MiniTest::Test
+  def setup
+    @handler = Pepito::Handlers::Info.new(nil)
+    @handler.run
+  end
+
+  def test_has_chat_routes
+    chat_routes = ['info']
+    @handler.chat_routes.each do |route|
+      chat_routes.entries.each do |r|
+        chat_routes.delete(r) if route.pattern.match(r)
+      end
+    end
+    assert_empty chat_routes
+  end
+
+  def test_has_web_routes
+    http_routes = [
+      { method: 'GET', path: '/info' }
+    ]
+    @handler.http_routes.each do |route|
+      http_routes.entries.each do |r|
+        http_routes.delete(r) if route.route.path_for_generation == r[:path] && route.route.request_methods.include?(r[:method])
+      end
+    end
+    assert_empty http_routes
+  end
+end

data/test/pepito/handlers/test_room.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'pepito/handlers/room'
+
+class TestPepitoHandlersRoom < MiniTest::Test
+  def setup
+    @handler = Pepito::Handlers::Room.new(nil)
+    @handler.run
+  end
+
+  def test_has_chat_routes
+    chat_routes = ['set topic word', 'set topic multiple words']
+    @handler.chat_routes.each do |route|
+      chat_routes.entries.each do |r|
+        chat_routes.delete(r) if route.pattern.match(r)
+      end
+    end
+    assert_empty chat_routes
+  end
+
+  def test_chat_set_topic
+    match_data = { 'topic' => 'topic' }
+    mock_adapter = MiniTest::Mock.new
+    mock_source = MiniTest::Mock.new
+
+    mock_adapter.expect(:topic, nil, [mock_source, match_data['topic']])
+    mock_source.expect(:adapter, mock_adapter)
+
+    @handler.chat_set_topic(mock_source, match_data)
+
+    mock_adapter.verify
+    mock_source.verify
+  end
+end

data/test/pepito/test_adapter.rb

@@ -0,0 +1,71 @@
+require 'minitest/autorun'
+require 'pepito/adapter'
+require 'pepito/errors/required_methods_error'
+
+class StubAdapter < Pepito::Adapter
+  class << self
+    attr_accessor :configs
+  end
+
+  Pepito::Adapter::REQUIRED_METHODS.each do |arg|
+    send :define_method, arg do
+      nil
+    end
+  end
+end
+
+class TestPepitoAdapter < MiniTest::Test
+  def test_raise_missing_methods
+    StubAdapter.configs = [{}]
+    e = assert_raises Pepito::Errors::RequiredMethodsError do
+      Pepito::Adapter.new(nil, {})
+    end
+
+    assert_equal e.missing_methods, Pepito::Adapter::REQUIRED_METHODS
+  end
+
+  def test_no_missing_methods
+    StubAdapter.configs = [{}]
+    StubAdapter.new(nil, {})
+    pass
+  end
+
+  def test_optional_config
+    StubAdapter.configs = [{ name: 'optional', required: false }]
+    StubAdapter.new(nil, {})
+    pass
+  end
+
+  def test_required_config
+    StubAdapter.configs = [{ name: 'required', required: true }]
+    StubAdapter.new(nil, 'required' => 'config_value')
+    pass
+  end
+
+  def test_missing_required_config
+    StubAdapter.configs = [{ name: 'required', required: true }]
+    e = assert_raises Pepito::Errors::MissingConfigurationValueError do
+      StubAdapter.new(nil, {})
+    end
+
+    assert_equal e.configuration_values, ['required']
+  end
+
+  def test_nil_required_config
+    StubAdapter.configs = [{ name: 'required', required: true }]
+    e = assert_raises Pepito::Errors::MissingConfigurationValueError do
+      StubAdapter.new(nil, 'required' => nil)
+    end
+
+    assert_equal e.configuration_values, ['required']
+  end
+
+  def test_empty_required_config
+    StubAdapter.configs = [{ name: 'required', required: true }]
+    e = assert_raises Pepito::Errors::MissingConfigurationValueError do
+      StubAdapter.new(nil, 'required' => '')
+    end
+
+    assert_equal e.configuration_values, ['required']
+  end
+end

data/test/pepito/test_handler.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+require 'pepito/handler'
+
+class TestPepitoHandler < MiniTest::Test
+  def test_http_routes_registry
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:route, nil)
+    mock_route.expect(:route, nil)
+
+    mock_router = MiniTest::Mock.new
+    mock_router.expect(:add_route, nil, [mock_route.route])
+
+    mock_http_api = MiniTest::Mock.new
+    mock_http_api.expect(:router, mock_router)
+
+    mock_robot = MiniTest::Mock.new
+    mock_robot.expect(:http_api, mock_http_api)
+
+    handler = Pepito::Handler.new(mock_robot)
+    handler.http_routes << mock_route
+    handler.start
+
+    assert mock_robot.verify
+    assert mock_http_api.verify
+    assert mock_router.verify
+    assert mock_route.verify
+  end
+end

data/test/pepito/test_message.rb

@@ -0,0 +1,101 @@
+require 'minitest/autorun'
+require 'pepito/message'
+
+class TestPepitoMessage < MiniTest::Test
+  def test_command_false
+    message = create_message('pepito', 'message')
+    assert_equal message.command?, false
+  end
+
+  def test_command_false_if_name_empty
+    message = create_message('', 'message')
+    assert_equal message.command?, false
+  end
+
+  def test_command_false_if_name_empty_and_space_in_message
+    message = create_message('', ' message')
+    assert_equal message.command?, false
+  end
+
+  def test_command_true
+    message = create_message('pepito', 'pepito message')
+    assert_equal message.command?, true
+    assert_equal message.command, 'message'
+  end
+
+  def test_route_match_true_if_command_false_and_route_command_false
+    message = create_message('pepito', 'message')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, false)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), true
+  end
+
+  def test_route_match_false_if_command_false_and_route_command_false
+    message = create_message('pepito', 'message asd')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, false)
+    mock_route.expect(:command, false)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), false
+  end
+
+  def test_route_match_true_if_command_true_and_route_command_true
+    message = create_message('pepito', 'pepito message')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, true)
+    mock_route.expect(:command, true)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), true
+  end
+
+  def test_route_match_false_if_command_true_and_route_command_true
+    message = create_message('pepito', 'pepito message asd')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, true)
+    mock_route.expect(:command, true)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), false
+  end
+
+  def test_route_match_if_command_true_and_route_command_false
+    message = create_message('pepito', 'pepito message')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, false)
+    mock_route.expect(:command, false)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), false
+  end
+
+  def test_route_match_if_command_false_and_route_command_true
+    message = create_message('pepito', 'message')
+
+    mock_route = MiniTest::Mock.new
+    mock_route.expect(:command, true)
+    mock_route.expect(:command, true)
+    mock_route.expect(:pattern, /^message$/)
+
+    assert_equal message.match_route?(mock_route), false
+  end
+
+  private
+
+  def create_message(name, body)
+    mock_robot = MiniTest::Mock.new
+    mock_robot.expect(:name, name)
+    mock_robot.expect(:name, name)
+    mock_robot.expect(:name, name)
+
+    Pepito::Message.new(mock_robot, nil, body)
+  end
+end

data/test/pepito/test_robot.rb

@@ -0,0 +1,259 @@
+require 'minitest/autorun'
+require 'pepito/robot'
+
+class TestPepitoRobot < MiniTest::Test
+  def setup
+    ENV['LOG_FILE'] = '/dev/null'
+
+    @mock_http_api = MiniTest::Mock.new
+    @mock_database = MiniTest::Mock.new
+    @mock_database.expect(:get, nil, ['name'])
+
+    Pepito::HTTPApi::RackApp.stub :new, @mock_http_api do
+      Pepito::Database.stub :new, @mock_database do
+        @robot = Pepito::Robot.new
+      end
+    end
+  end
+
+  def test_attributes
+    assert_equal 'pepito', @robot.name
+    assert_equal Pepito::WebApp::App, @robot.web_app
+    assert_instance_of Logger, @robot.logger
+    assert_instance_of Hash, @robot.handlers
+    assert_instance_of Hash, @robot.adapters
+    assert_instance_of Array, @robot.default_adapters
+    assert_instance_of Array, @robot.default_handlers
+    assert_empty @robot.handlers
+    assert_empty @robot.adapters
+  end
+
+  def test_methods
+    assert_respond_to @robot, :run
+    assert_respond_to @robot, :receive_message
+    assert_respond_to @robot, :start_handler
+    assert_respond_to @robot, :stop_handler
+    assert_respond_to @robot, :handler?
+    assert_respond_to @robot, :handlers_list
+    assert_respond_to @robot, :start_adapter
+    assert_respond_to @robot, :stop_adapter
+    assert_respond_to @robot, :adapter?
+    assert_respond_to @robot, :adapters_list
+  end
+
+  def test_handlers_list
+    assert_instance_of Array, @robot.handlers_list
+  end
+
+  def test_adapters_list
+    assert_instance_of Array, @robot.adapters_list
+  end
+
+  def test_start_handler
+    # Fail to start if handler is running
+    @robot.handlers.stub :key?, true do
+      assert_equal 1, @robot.start_handler('')
+    end
+
+    # Fail to start if handler does not exist
+    @robot.handlers.stub :key?, false do
+      assert_equal 2, @robot.start_handler('')
+    end
+
+    # Fail with other errors
+    @robot.handlers.stub :key?, false do
+      mock_handler = Class.new do
+        def initialize(_robot)
+          raise 'error'
+        end
+      end
+      Pepito::Handlers.stub :const_get, mock_handler do
+        assert_equal 3, @robot.start_handler('')
+      end
+    end
+
+    # Start handler successfully
+    @robot.handlers.stub :key?, false do
+      name = 'handler_name'
+
+      mock_handler = MiniTest::Mock.new
+      mock_handler.expect(:run, nil)
+      mock_handler.expect(:start, nil)
+
+      mock_handler_klass = MiniTest::Mock.new
+      mock_handler_klass.expect(:new, mock_handler, [@robot])
+
+      mock_router = MiniTest::Mock.new
+      mock_router.expect(:uncompile, nil)
+
+      @mock_http_api.expect(:router, mock_router)
+      @mock_database.expect(:sadd, nil, ['handlers', name])
+
+      Pepito::Handlers.stub :const_get, mock_handler_klass do
+        assert_equal 0, @robot.start_handler(name)
+        assert mock_handler.verify
+        assert mock_router.verify
+        assert mock_handler_klass.verify
+        assert @mock_http_api.verify
+        assert @mock_database.verify
+      end
+    end
+  end
+
+  def test_stop_handler
+    # Fail to stop if handler is in the default handlers list
+    @robot.default_handlers.stub :include?, true do
+      assert_equal 1, @robot.stop_handler('')
+    end
+
+    # Fail to stop if handler is not running
+    @robot.default_handlers.stub :include?, false do
+      @robot.handlers.stub :key?, false do
+        assert_equal 2, @robot.stop_handler('')
+      end
+    end
+
+    # Stop successfully otherwise
+    @robot.default_handlers.stub :include?, false do
+      @robot.handlers.stub :key?, true do
+        @robot.handlers.stub :delete, nil do
+          name = 'handler'
+          mock_router = MiniTest::Mock.new
+          mock_router.expect(:reset!, nil)
+          @mock_database.expect(:srem, nil, ['handlers', name])
+          @mock_http_api.expect(:router, mock_router)
+
+          assert_equal 0, @robot.stop_handler(name)
+          assert mock_router.verify
+          assert @mock_http_api.verify
+          assert @mock_database.verify
+        end
+      end
+    end
+  end
+
+  def test_handler?
+    @robot.handlers.stub :key?, true do
+      assert @robot.handler?('')
+    end
+    @robot.handlers.stub :key?, false do
+      refute @robot.handler?('')
+    end
+  end
+
+  def test_start_adapter
+    # Fail to start if handler is running
+    @robot.adapters.stub :key?, true do
+      assert_equal 1, @robot.start_adapter('', {})
+    end
+
+    # Fail to start if handler does not exist
+    @robot.adapters.stub :key?, false do
+      assert_equal 2, @robot.start_adapter('', {})
+    end
+
+    # Fail if required methods missing
+    @robot.adapters.stub :key?, false do
+      mock_adapter = Class.new do
+        def initialize(_robot, _config)
+          raise Pepito::Errors::RequiredMethodsError.new([]), ''
+        end
+      end
+      Pepito::Adapters.stub :const_get, mock_adapter do
+        assert_equal 3, @robot.start_adapter('', {})
+      end
+    end
+
+    # Fail if missing configuration
+    @robot.adapters.stub :key?, false do
+      mock_adapter = Class.new do
+        def initialize(_robot, _config)
+          raise Pepito::Errors::MissingConfigurationValueError.new([]), ''
+        end
+      end
+      Pepito::Adapters.stub :const_get, mock_adapter do
+        assert_equal 4, @robot.start_adapter('', {})
+      end
+    end
+
+    # Fail with other errors
+    @robot.adapters.stub :key?, false do
+      mock_adapter = Class.new do
+        def initialize(_robot, _config)
+          raise 'error'
+        end
+      end
+      Pepito::Adapters.stub :const_get, mock_adapter do
+        assert_equal 5, @robot.start_adapter('', {})
+      end
+    end
+
+    # Start adapter successfully
+    @robot.adapters.stub :key?, false do
+      name = 'adapter_name'
+      config = { 'name' => 'option' }
+
+      mock_adapter = MiniTest::Mock.new
+      mock_adapter.expect(:run, nil)
+
+      mock_adapter_klass = MiniTest::Mock.new
+      mock_adapter_klass.expect(:new, mock_adapter, [@robot, config])
+
+      @mock_database.expect(:sadd, nil, ['adapters', name])
+      @mock_database.expect(:del, nil, [name])
+      config.each do |k, v|
+        @mock_database.expect(:hset, nil, [name, k, v])
+      end
+
+      Pepito::Adapters.stub :const_get, mock_adapter_klass do
+        Thread.stub :new, nil do
+          assert_equal 0, @robot.start_adapter(name, config)
+          assert mock_adapter.verify
+          assert mock_adapter_klass.verify
+          assert @mock_database.verify
+        end
+      end
+    end
+  end
+
+  def test_stop_adapter
+    # Fail to stop if adapter is in the default adapters list
+    @robot.default_adapters.stub :include?, true do
+      assert_equal 1, @robot.stop_adapter('')
+    end
+
+    # Fail to stop if adapter is not running
+    @robot.default_adapters.stub :include?, false do
+      @robot.adapters.stub :key?, false do
+        assert_equal 2, @robot.stop_adapter('')
+      end
+    end
+
+    # Stop successfully otherwise
+    @robot.default_adapters.stub :include?, false do
+      @robot.adapters.stub :key?, true do
+        @robot.adapters.stub :delete, nil do
+          mock_adapter = MiniTest::Mock.new
+          mock_adapter.expect(:stop, nil)
+          @robot.adapters.stub :[], mock_adapter do
+            name = 'adapter'
+            @mock_database.expect(:srem, nil, ['adapters', name])
+
+            assert_equal 0, @robot.stop_adapter(name)
+            assert mock_adapter.verify
+            assert @mock_database.verify
+          end
+        end
+      end
+    end
+  end
+
+  def test_adapter?
+    @robot.adapters.stub :key?, true do
+      assert @robot.adapter?('')
+    end
+    @robot.adapters.stub :key?, false do
+      refute @robot.adapter?('')
+    end
+  end
+end

data/test/pepito/test_source.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+require 'pepito/source'
+
+class TestPepitoSource < MiniTest::Test
+  def setup
+    @mock_adapter = MiniTest::Mock.new
+    @mock_adapter.expect(:==, true, [@mock_adapter])
+
+    @source = Pepito::Source.new(@mock_adapter, 'user', 'room', false)
+  end
+
+  def test_adapter_assignment
+    assert_equal @source.adapter, @mock_adapter
+  end
+
+  def test_user_assignment
+    assert_equal @source.user, 'user'
+  end
+
+  def test_room_assignment
+    assert_equal @source.room, 'room'
+  end
+
+  def test_private_message_assignment
+    assert_equal @source.private_message, false
+  end
+end

data/test/test_pepito.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require 'pepito'
+
+class TestPepito < MiniTest::Test
+  def test_redis_namespace_is_pepito
+    assert_equal :pepito, Pepito::REDIS_NAMESPACE
+  end
+end