tynn 1.4.0 → 2.0.0.alpha

data/test/middleware_test.rb

@@ -1,79 +1,88 @@
-class Shrimp
-  def initialize(app)
-    @app = app
-  end
+# frozen_string_literal: true
 
-  def call(env)
-    status, headers, body = @app.call(env)
+require_relative "helper"
 
-    return [status, headers, body.reverse]
-  end
-end
+class MiddlewareTest < Minitest::Test
+  class Shrimp
+    def initialize(app)
+      @app = app
+    end
 
-test "middleware in main application" do
-  Tynn.use(Shrimp)
+    def call(env)
+      status, headers, body = @app.call(env)
 
-  Tynn.define do
-    get do
-      res.write("1")
-      res.write("2")
+      [status, headers, body.reverse]
     end
   end
 
-  app = Tynn::Test.new
-  app.get("/")
+  def test_middleware_works
+    app = Class.new(Tynn)
 
-  assert_equal 200, app.res.status
-  assert_equal "21", app.res.body
-end
+    app.use(Shrimp)
 
-test "middleware with composition" do
-  Tynn.use(Shrimp)
-
-  Tynn.define do
-    on "api" do
-      run(API)
+    app.define do
+      get do
+        res.write("1")
+        res.write("2")
+      end
     end
-  end
 
-  class API < Tynn
+    ts = Tynn::Test.new(app)
+    ts.get("/")
+
+    assert_equal 200, ts.res.status
+    assert_equal "21", ts.res.body
   end
 
-  API.define do
-    get do
-      res.write("1")
-      res.write("2")
+  def test_middleware_with_composition
+    app = Class.new(Tynn)
+    api = Class.new(Tynn)
+
+    app.use(Shrimp)
+
+    app.define do
+      on("api") do
+        run(api)
+      end
     end
-  end
 
-  app = Tynn::Test.new
-  app.get("/api")
+    api.define do
+      get do
+        res.write("1")
+        res.write("2")
+      end
+    end
 
-  assert_equal 200, app.res.status
-  assert_equal "21", app.res.body
-end
+    ts = Tynn::Test.new(app)
+    ts.get("/api")
 
-test "middleware only in child application" do
-  class API < Tynn
-    use(Shrimp)
+    assert_equal 200, ts.res.status
+    assert_equal "21", ts.res.body
   end
 
-  Tynn.define do
-    on "api" do
-      run(API)
+  def test_middleware_for_sub_application
+    app = Class.new(Tynn)
+    api = Class.new(Tynn)
+
+    api.use(Shrimp)
+
+    app.define do
+      on("api") do
+        run(api)
+      end
     end
-  end
 
-  API.define do
-    get do
-      res.write("1")
-      res.write("2")
+    api.define do
+      get do
+        res.write("1")
+        res.write("2")
+      end
     end
-  end
 
-  app = Tynn::Test.new
-  app.get("/api")
+    ts = Tynn::Test.new(app)
+    ts.get("/api")
 
-  assert_equal 200, app.res.status
-  assert_equal "21", app.res.body
+    assert_equal 200, ts.res.status
+    assert_equal "21", ts.res.body
+  end
 end

data/test/plugin_test.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class PluginTest < Minitest::Test
+  def setup
+    @app = Class.new(Tynn)
+  end
+
+  def test_class_methods
+    mod = Module.new do
+      def foo
+        "foo"
+      end
+    end
+
+    plugin = Module.new
+    plugin.const_set(:ClassMethods, mod)
+
+    @app.plugin(plugin)
+
+    assert_equal "foo", @app.foo
+  end
+
+  def test_instance_methods
+    mod = Module.new do
+      def bar
+        "bar"
+      end
+    end
+
+    plugin = Module.new
+    plugin.const_set(:InstanceMethods, mod)
+
+    @app.plugin(plugin)
+
+    assert_equal "bar", @app.new(proc {}).bar
+  end
+
+  def test_setup
+    plugin = Module.new
+
+    def plugin.run?
+      @run
+    end
+
+    def plugin.setup(_)
+      @run = true
+    end
+
+    @app.plugin(plugin)
+
+    assert_equal true, plugin.run?
+  end
+
+  def test_setup_passes_app
+    plugin = Module.new
+
+    def plugin.app
+      @__app
+    end
+
+    def plugin.setup(app)
+      @__app = app
+    end
+
+    @app.plugin(plugin)
+
+    assert_equal @app, plugin.app
+  end
+
+  def test_setup_with_arguments
+    plugin = Module.new
+
+    def plugin.args
+      @args
+    end
+
+    def plugin.setup(_, foo, bar)
+      @args = [foo, bar]
+    end
+
+    @app.plugin(plugin, "foo", "bar")
+
+    assert_equal %w(foo bar), plugin.args
+  end
+
+  def test_setup_with_keyword_arguments
+    plugin = Module.new
+
+    def plugin.args
+      @args
+    end
+
+    def plugin.setup(_, foo:, bar: "bar")
+      @args = [foo, bar]
+    end
+
+    @app.plugin(plugin, foo: "foo")
+
+    assert_equal %w(foo bar), plugin.args
+  end
+
+  def test_setup_with_block
+    plugin = Module.new
+
+    def plugin.block
+      @block
+    end
+
+    def plugin.setup(_, &block)
+      @block = block
+    end
+
+    @app.plugin(plugin) do
+      "foo"
+    end
+
+    assert_equal "foo", plugin.block.call
+  end
+end

data/test/render_test.rb

@@ -1,92 +1,83 @@
-require "erubis"
+# frozen_string_literal: true
+
+require_relative "helper"
 require_relative "../lib/tynn/render"
+require "tilt/erubis"
 
-setup do
-  Tynn.plugin(Tynn::Render, views: File.expand_path("./test/views"))
+class RenderTest < Minitest::Test
+  VIEWS_PATH = File.expand_path("views", __dir__)
 
-  Tynn::Test.new
-end
+  def setup
+    @app = Class.new(Tynn)
 
-test "partial" do |app|
-  Tynn.define do
-    on "partial" do
-      res.write(partial("partial", name: "erb"))
-    end
+    @app.plugin(Tynn::Render, views: VIEWS_PATH)
   end
 
-  app.get("/partial")
-
-  assert_equal "erb", app.res.body.strip
-end
-
-test "view" do |app|
-  Tynn.define do
-    on "view" do
-      res.write(view("view", title: "tynn", name: "erb"))
+  def test_partial
+    @app.define do
+      on("partial") do
+        res.write(partial("partial", name: "alice"))
+      end
     end
-  end
-
-  app.get("/view")
 
-  assert_equal "tynn / erb", app.res.body.strip
-end
+    ts = Tynn::Test.new(@app)
+    ts.get("/partial")
 
-test "render" do |app|
-  Tynn.define do
-    on "render" do
-      render("view", title: "tynn", name: "erb")
-    end
+    assert_equal "alice", ts.res.body.strip
   end
 
-  app.get("/render")
-
-  assert_equal 200, app.res.status
-  assert_equal "text/html", app.res.headers["Content-Type"]
-  assert_equal "tynn / erb", app.res.body.strip
-end
+  def test_view
+    @app.define do
+      on("view") do
+        res.write(view("view", title: "welcome", name: "alice"))
+      end
+    end
 
-test "404" do |app|
-  Tynn.define do
-    on "404" do
-      res.status = 404
+    ts = Tynn::Test.new(@app)
+    ts.get("/view")
 
-      render("view", title: "tynn", name: "erb")
-    end
+    assert_equal "welcome / alice", ts.res.body.strip
   end
 
-  app.get("/404")
+  def test_render
+    @app.define do
+      on("render") do
+        render("view", title: "welcome", name: "alice")
+      end
+    end
 
-  assert_equal 404, app.res.status
-  assert_equal "text/html", app.res.headers["Content-Type"]
-  assert_equal "tynn / erb", app.res.body.strip
-end
+    ts = Tynn::Test.new(@app)
+    ts.get("/render")
 
-test "custom layout" do
-  class App < Tynn
-    set :layout, "custom_layout"
+    assert_equal "text/html", ts.res.content_type
+    assert_equal "welcome / alice", ts.res.body.strip
   end
 
-  App.define do
-    root do
-      render("view", title: "tynn", name: "erb")
+  def test_escaping
+    @app.define do
+      on("escape") do
+        res.write(partial("partial", name: "<a></a>"))
+      end
     end
-  end
 
-  app = Tynn::Test.new(App)
-  app.get("/")
+    ts = Tynn::Test.new(@app)
+    ts.get("/escape")
 
-  assert_equal "custom / tynn / erb", app.res.body.strip
-end
+    assert_equal "&lt;a&gt;&lt;/a&gt;", ts.res.body.strip
+  end
+
+  def test_custom_layout
+    @app.set(:render, layout: "custom_layout")
 
-test "escapes by default" do
-  Tynn.define do
-    root do
-      res.write(partial("partial", name: "<a></a>"))
+    @app.define do
+      get do
+        render("view", title: "welcome", name: "alice")
+      end
     end
-  end
 
-  app = Tynn::Test.new
-  app.get("/")
+    ts = Tynn::Test.new(@app)
+    ts.get("/")
 
-  assert_equal "&lt;a&gt;&lt;/a&gt;", app.res.body.strip
+    assert_equal "custom / welcome / alice", ts.res.body.strip
+  end
 end

data/test/request_headers_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class RequestHeadersTest < Minitest::Test
+  def setup
+    env = { "HTTP_HOST" => "127.0.0.1", "CONTENT_TYPE" => "text/plain" }
+    request = Tynn::Request.new(env)
+
+    @headers = Tynn::Request::Headers.new(request)
+  end
+
+  def test_get_header
+    assert_equal "127.0.0.1", @headers["Host"]
+  end
+
+  def test_check_if_key_exists
+    assert @headers.key?("Host")
+  end
+
+  def test_fetch
+    assert_equal "text/plain", @headers.fetch("content-type")
+  end
+
+  def test_fetch_raises_if_key_not_exists
+    assert_raises(KeyError) { @headers.fetch("not-exists") }
+  end
+
+  def test_fetch_with_default
+    assert_equal "not exists", @headers.fetch("not-exists", "not exists")
+    assert_equal "not exists", @headers.fetch("not-exists") { "not exists" }
+  end
+end

data/test/routing_test.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+class RoutingTest < Minitest::Test
+  def setup
+    @app = Class.new(Tynn)
+  end
+
+  def test_raise_if_not_handler
+    assert_raises { @app.call({}) }
+  end
+
+  def test_path_matching
+    @app.define do
+      on "hello" do
+        res.write("hello")
+      end
+    end
+
+    ts = Tynn::Test.new(@app)
+    ts.get("/")
+
+    assert_equal 404, ts.res.status
+
+    ts.get("/hello")
+
+    assert_equal 200, ts.res.status
+    assert_equal "hello", ts.res.body
+  end
+
+  def test_http_methods
+    methods = %i(get post put patch delete head options)
+
+    methods.each do |method|
+      @app.define do
+        send(method) { res.write(method) }
+      end
+
+      ts = Tynn::Test.new(@app)
+      ts.send(method, "/")
+
+      assert_equal 200, ts.res.status
+      assert_equal method.to_s, ts.res.body
+    end
+  end
+
+  def test_capturing_path
+    @app.define do
+      on(:foo) do |foo|
+        on(:bar) do |bar|
+          res.write(sprintf("%s/%s", foo, bar))
+        end
+      end
+    end
+
+    ts = Tynn::Test.new(@app)
+    ts.get("/john/doe")
+
+    assert_equal 200, ts.res.status
+    assert_equal "john/doe", ts.res.body
+  end
+
+  def test_composition
+    foo = Class.new(@app)
+
+    @app.define do
+      on("foo") do
+        run(foo, foo: 42)
+      end
+    end
+
+    foo.define do
+      get do
+        res.write(inbox[:foo])
+      end
+    end
+
+    ts = Tynn::Test.new(@app)
+    ts.get("/foo")
+
+    assert_equal 200, ts.res.status
+    assert_equal "42", ts.res.body
+  end
+
+  def test_request_class
+    @app.define do
+      get do
+        res.write(req.class.name)
+      end
+    end
+
+    ts = Tynn::Test.new(@app)
+    ts.get("/")
+
+    assert_equal Tynn::Request.name, ts.res.body
+  end
+
+  def test_response_class
+    @app.define do
+      get do
+        res.write(res.class.name)
+      end
+    end
+
+    ts = Tynn::Test.new(@app)
+    ts.get("/")
+
+    assert_equal Tynn::Response.name, ts.res.body
+  end
+end