api-transformer 0.1.0

data/spec/server_spec.rb

@@ -0,0 +1,746 @@
+require "goliath/test_helper"
+require "goliath/test_helper_streaming"
+
+require_relative "./spec_helper"
+require_relative "../lib/api_transformer"
+
+def create_server(&block)
+  server = Class.new(ApiTransformer::Server) do
+    base_url "http://localhost:9900"
+  end
+
+  server.instance_eval(&block)
+
+  server
+end
+
+def extend_server(server, &block)
+  server.instance_eval(&block)
+  server
+end
+
+def echo_greeting_server
+  create_server do
+    get "/echo_greeting" do |params|
+      response do
+        attribute :greeting, params[:greeting]
+      end
+    end
+  end
+end
+
+describe ApiTransformer::Server do
+  include Goliath::TestHelper
+
+  let(:err) { proc { |c| fail "HTTP Request failed #{c.response}" } }
+
+  before do
+    ApiTransformer::Server.reset_routes
+  end
+
+  it "works without any backend requests" do
+    no_backend = create_server do
+      get "/ping" do
+        response do
+          success { attribute :result, "pong" }
+        end
+      end
+    end
+
+    with_api(no_backend) do
+      get_request(path: "/ping") do |c|
+        c.response.must_equal '{"result":"pong"}'
+      end
+    end
+  end
+
+  it "works with a backend request" do
+    backend = create_server do
+      get "/one" do
+        request :two do
+          path "/two"
+          method :get
+        end
+
+        response do |data|
+          success { attribute :two, data[:two].json }
+        end
+      end
+
+      get "/two" do
+        response do
+          success { attribute :result, "OK" }
+        end
+      end
+    end
+
+    with_api(backend) do
+      get_request(path: "/one") do |c|
+        c.response.must_equal '{"two":{"result":"OK"}}'
+      end
+    end
+  end
+
+  it "fails without a method on backend requests" do
+    server = create_server do
+      get "/nomethod" do
+        request :somewhere do
+          path "/somewhere"
+        end
+
+        response do
+          success 204
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/nomethod") do |c|
+        c.response.must_equal "Missing method for backend request: somewhere"
+      end
+    end
+  end
+
+  it "works with a namespace" do
+    namspaced = create_server do
+      namespace "/first" do
+        get "/second" do
+          response do
+            success { attribute :result, "Found me!" }
+          end
+        end
+      end
+    end
+
+    with_api(namspaced) do
+      get_request(path: "/first/second") do |c|
+        c.response.must_equal '{"result":"Found me!"}'
+      end
+    end
+  end
+
+  it "accepts path params from incoming requests" do
+    server = create_server do
+      get "/echo_greeting/:greeting" do |params|
+        response do
+          attribute :greeting, params[:greeting]
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/echo_greeting/hola") do |c|
+        c.response.must_equal '{"greeting":"hola"}'
+      end
+    end
+  end
+
+  it "accepts query params from incoming requests" do
+    with_api(echo_greeting_server) do
+      get_request(path: "/echo_greeting", query: { greeting: "yo" }) do |c|
+        c.response.must_equal '{"greeting":"yo"}'
+      end
+    end
+  end
+
+  it "accepts form params from incoming requests" do
+    with_api(echo_greeting_server) do
+      get_request(path: "/echo_greeting", body: { greeting: "hullo" }) do |c|
+        c.response.must_equal '{"greeting":"hullo"}'
+      end
+    end
+  end
+
+  it "accepts json params from incoming requests" do
+    with_api(echo_greeting_server) do
+      get_request(
+        path: "/echo_greeting",
+        body: '{"greeting":"howdy"}',
+        head: { "Content-Type" => "application/json" }
+      ) do |c|
+        c.response.must_equal '{"greeting":"howdy"}'
+      end
+    end
+  end
+
+  it "sends query params in backend requests" do
+    proxy_query = extend_server echo_greeting_server do
+      get "/proxy_query_param" do
+        request :echo do
+          path "/echo_greeting"
+          method :get
+
+          query_param :greeting, "hello"
+        end
+
+        response do |data|
+          attribute :greeting, data[:echo][:greeting]
+        end
+      end
+    end
+
+    with_api(proxy_query) do
+      get_request(path: "/proxy_query_param") do |c|
+        c.response.must_equal '{"greeting":"hello"}'
+      end
+    end
+  end
+
+  it "sends form params in backend requests" do
+    proxy_form = extend_server echo_greeting_server do
+      get "/proxy_form_param" do
+        request :echo do
+          path "/echo_greeting"
+          method :get
+
+          form_param :greeting, "hello"
+        end
+
+        response do |data|
+          attribute :greeting, data[:echo][:greeting]
+        end
+      end
+    end
+
+    with_api(proxy_form) do
+      get_request(path: "/proxy_form_param") do |c|
+        c.response.must_equal '{"greeting":"hello"}'
+      end
+    end
+  end
+
+  describe "json params" do
+    it "sends json params in backend requests" do
+      proxy_json = extend_server echo_greeting_server do
+        get "/proxy_json_param" do
+          request :echo do
+            path "/echo_greeting"
+            method :get
+
+            json_param :greeting, "hello"
+          end
+
+          response do |data|
+            attribute :greeting, data[:echo][:greeting]
+          end
+        end
+      end
+
+      with_api(proxy_json) do
+        get_request(path: "/proxy_json_param") do |c|
+          c.response.must_equal '{"greeting":"hello"}'
+        end
+      end
+    end
+
+    it "does not allow both json and form params together" do
+      conflicting_params = create_server do
+        get "/conflicting_params" do
+          request :echo do
+            path "/echo_greeting"
+            method :get
+
+            json_param :greeting, "hello"
+            form_param :name, "Bob"
+          end
+
+          response do |data|
+            attribute :greeting, data[:echo][:greeting]
+          end
+        end
+      end
+
+      with_api(conflicting_params) do
+        get_request(path: "/conflicting_params") do |c|
+          c.response.must_equal "A request cannot have both json and form " \
+            "parameters"
+        end
+      end
+    end
+  end
+
+  # TODO: make this test work
+  # It works if the /proxy_cookie_param and /echo_greeting endpoints are run
+  # in an actual server instance, but not here in the test.
+  #
+  # it "sends cookie params in backend requests" do
+  #   proxy_cookie = extend_server echo_greeting_server do
+  #     get "/proxy_cookie_param" do
+  #       request :echo do
+  #         path "/echo_greeting"
+  #         method :get
+
+  #         cookie_param :greeting, "hello"
+  #       end
+
+  #       response do |data|
+  #         attribute :greeting, data[:echo][:greeting]
+  #       end
+  #     end
+  #   end
+
+  #   with_api(proxy_cookie) do
+  #     get_request(path: "/proxy_cookie_param") do |c|
+  #       c.response.must_equal '{"greeting":"hello"}'
+  #     end
+  #   end
+  # end
+
+  it "handles frontend post requests" do
+    frontend_post = create_server do
+      post "/ping" do
+        response do
+          success { attribute :result, "pong" }
+        end
+      end
+    end
+
+    with_api(frontend_post) do
+      post_request(path: "/ping") do |c|
+        c.response.must_equal '{"result":"pong"}'
+      end
+    end
+  end
+
+  it "handles frontend put requests" do
+    frontend_post = create_server do
+      put "/ping" do
+        response do
+          success { attribute :result, "pong" }
+        end
+      end
+    end
+
+    with_api(frontend_post) do
+      put_request(path: "/ping") do |c|
+        c.response.must_equal '{"result":"pong"}'
+      end
+    end
+  end
+
+  it "handles frontend delete requests" do
+    frontend_post = create_server do
+      delete "/ping" do
+        response do
+          success { attribute :result, "pong" }
+        end
+      end
+    end
+
+    with_api(frontend_post) do
+      delete_request(path: "/ping") do |c|
+        c.response.must_equal '{"result":"pong"}'
+      end
+    end
+  end
+
+  it "passes frontend request headers through to backend requests" do
+    echo_header = create_server do
+      get "/proxy" do
+        request :echo do
+          path "/echo"
+          method :get
+        end
+
+        response do |data|
+          success { attribute :result, data[:echo][:header] }
+        end
+      end
+
+      get "/echo" do |_, headers|
+        response do
+          success { attribute :header, headers["Bob-Content"] }
+        end
+      end
+    end
+
+    with_api(echo_header) do
+      get_request(
+        path: "/proxy",
+        head: { "Bob-Content" => "bob/classic" }
+      ) do |c|
+        c.response.must_equal '{"result":"bob/classic"}'
+      end
+    end
+  end
+
+  it "can set the entire body of the reponse" do
+    server = create_server do
+      get "/endpoint" do
+        response do
+          success { body "free form text!" }
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/endpoint") do |c|
+        c.response.must_equal "free form text!"
+      end
+    end
+  end
+
+  it "can respond with objects" do
+    class Bob
+      def initialize(last_name)
+        @last_name = last_name
+      end
+
+      def to_hash
+        { first_name: "Bob", last_name: @last_name }
+      end
+    end
+
+    object_response = create_server do
+      get "/object" do
+        response do
+          success { object :bob, Bob, "Saget" }
+        end
+      end
+    end
+
+    with_api(object_response) do
+      get_request(path: "/object") do |c|
+        c.response.must_equal '{"bob":{"first_name":"Bob","last_name":"Saget"}}'
+      end
+    end
+  end
+
+  it "can respond with arrays" do
+    # Example serialization class
+    class Bob
+      def initialize(last_name)
+        @last_name = last_name
+      end
+
+      def to_hash
+        { first_name: "Bob", last_name: @last_name }
+      end
+    end
+
+    object_response = create_server do
+      get "/object" do
+        response do
+          success { array :bobs, Bob, %w(Ross Marley) }
+        end
+      end
+    end
+
+    with_api(object_response) do
+      get_request(path: "/object") do |c|
+        c.response.must_equal '{"bobs":[' \
+          '{"first_name":"Bob","last_name":"Ross"},' \
+          '{"first_name":"Bob","last_name":"Marley"}' \
+          "]}"
+      end
+    end
+  end
+
+  it "can respond with cookies" do
+    server = create_server do
+      get "/cookie" do
+        response do
+          success { cookie "cookie-monster", "mmm... cookie" }
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/cookie") do |c|
+        expected = "cookie-monster=mmm... cookie"
+        c.response_header["Set-Cookie"].must_equal expected
+      end
+    end
+  end
+
+  it "can respond with a specified content type" do
+    server = create_server do
+      get "/endpoint" do
+        response do
+          success { content_type "image/jpeg" }
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/endpoint") do |c|
+        c.response_header["CONTENT_TYPE"].must_equal "image/jpeg"
+      end
+    end
+  end
+
+  it "makes the results of requests available to subsequent requests" do
+    multiple_requests = create_server do
+      get "/multi" do
+        request :one do
+          path "/one"
+          method :get
+        end
+
+        request :two do |data|
+          path "/two"
+          method :get
+
+          query_param :name, data[:one][:name]
+        end
+
+        response do |data|
+          success do
+            attribute :name, data[:two][:result]
+            cookie "type", data[:two].cookies[:type]
+          end
+        end
+      end
+
+      get "/one" do
+        response do
+          success { attribute :name, "Bob" }
+        end
+      end
+
+      get "/two" do |params|
+        response do
+          success do
+            attribute :result, params[:name]
+            cookie "type", "delicious"
+          end
+        end
+      end
+    end
+
+    with_api(multiple_requests) do
+      get_request(path: "/multi") do |c|
+        c.response.must_equal '{"name":"Bob"}'
+        c.response_header["Set-Cookie"].must_equal "type=delicious"
+      end
+    end
+  end
+
+  it "allows conditional requests" do
+    server = create_server do
+      get "/conditional" do
+        request :nonexistent, when: false do
+          path "/nonexistent"
+          method :get
+        end
+
+        response do
+          success { attribute :result, "OK" }
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/conditional") do |c|
+        c.response.must_equal '{"result":"OK"}'
+      end
+    end
+  end
+
+  it "streams downloads" do
+    server = create_server do
+      get "/one" do
+        stream true
+
+        request :two do
+          path "/two"
+          method :get
+        end
+
+        response do |data|
+          success do
+            stream do
+              data[:two].stream do |chunk|
+                stream_write chunk
+              end
+            end
+          end
+        end
+      end
+
+      get "/two" do
+        stream true
+
+        response do
+          success do
+            stream do
+              (1..9).each { |n| stream_write n }
+            end
+          end
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/one") do |c|
+        c.response.must_equal "123456789"
+      end
+    end
+  end
+
+  it "supports failure handlers in the response declaration" do
+    server = create_server do
+      get "/fail" do
+        response do
+          failure true do
+            status 422
+            attribute :result, "fail"
+          end
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/fail") do |c|
+        c.response.must_equal '{"result":"fail"}'
+      end
+    end
+  end
+
+  it "responds with the first matching failure handler" do
+    server = create_server do
+      get "/doublefail" do
+        response do
+          failure true do
+            attribute :fail, "one"
+          end
+
+          failure true do
+            attribute :fail, "two"
+          end
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/doublefail") do |c|
+        c.response.must_equal '{"fail":"one"}'
+      end
+    end
+  end
+
+  it "checks unhandled failures" do
+    server = create_server do
+      unhandled_failures do |data|
+        failure data.status == 400 do
+          status 422
+          attribute :fail, "yep"
+        end
+      end
+
+      get "/unhandled" do
+        request :fail do
+          path "/fail"
+          method :get
+        end
+
+        response do
+          success { attribute :result, "win" }
+        end
+      end
+
+      get "/fail" do
+        response do
+          success do
+            status 400
+          end
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/unhandled") do |c|
+        c.response.must_equal '{"fail":"yep"}'
+      end
+    end
+  end
+
+  it "passes through completely unhandled failures" do
+    server = create_server do
+      get "/completely_unhandled" do
+        request :fail do
+          path "/fail"
+          method :get
+        end
+
+        response do
+          success { attribute :result, "win" }
+        end
+      end
+
+      get "/fail" do
+        response do
+          success do
+            status 400
+            attribute :oh, "no"
+          end
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/completely_unhandled") do |c|
+        c.response.must_equal '{"oh":"no"}'
+      end
+    end
+  end
+
+  it "does not crash when there are no routes for an HTTP verb" do
+    server = create_server do
+      get "/ping" do
+        response do
+          success { attribute :result, "pong" }
+        end
+      end
+    end
+
+    with_api(server) do
+      post_request(path: "/whatever") do |c|
+        c.response.must_equal "nope"
+      end
+    end
+  end
+
+  it "allows a shorthand for setting success response status" do
+    server = create_server do
+      get "/no_body" do
+        response do
+          success 204
+        end
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/no_body") do |c|
+        c.response_header.http_status.must_equal 204
+        c.response.must_equal ""
+      end
+    end
+  end
+
+  it "provides a way to add helper methods" do
+    server = create_server do
+      helpers do
+        def victory_attribute
+          attribute :result, "VICTORY"
+        end
+
+        def victory!
+          response do
+            success { victory_attribute }
+          end
+        end
+      end
+
+      get "/status" do
+        victory!
+      end
+    end
+
+    with_api(server) do
+      get_request(path: "/status") do |c|
+        c.response.must_equal '{"result":"VICTORY"}'
+      end
+    end
+  end
+end