shaf 0.1.0.beta

data/lib/shaf/helpers/session.rb

@@ -0,0 +1,53 @@
+require 'digest'
+
+module Shaf
+  module Session
+
+    SESSION_TTL = 60 * 60 * 24 * 2 # 2 days
+
+    def login(email, password)
+      return unless email && password
+      user = User.first(email: email) or return
+      bcrypt = BCrypt::Password.new(user.password_digest)
+      return unless bcrypt == password
+      @current_user = user
+
+      Session.where(user_id: user.id).delete
+      params = {
+        user_id: user.id,
+        expire_at: Time.now + SESSION_TTL,
+      }
+      Session.create(params)
+    end
+
+    def extend_session(session)
+      return unless session
+      session.update(expire_at: Time.now + SESSION_TTL)
+      session.auth_token = request.env['HTTP_X_AUTH_TOKEN']
+      session
+    end
+
+    def logout
+      current_session&.destroy
+    end
+
+    def current_user
+      unless defined?(@current_user) && @current_user
+        return unless request.env.key? 'HTTP_X_AUTH_TOKEN'
+        digest = Digest::SHA256.hexdigest(request.env['HTTP_X_AUTH_TOKEN'])
+        session = Session.where(auth_token_digest: digest).first
+        @current_user = User[session.user_id] if session&.valid?
+      end
+      @current_user
+    end
+
+    def current_session
+      unless @current_session
+        return unless current_user
+        @current_session = Session.where(user_id: current_user.id).first
+      end
+      @current_session
+    end
+
+  end
+end

data/lib/shaf/middleware.rb

@@ -0,0 +1 @@
+require 'shaf/middleware/request_id'

data/lib/shaf/middleware/request_id.rb

@@ -0,0 +1,16 @@
+require 'securerandom'
+
+module Shaf
+  module Middleware
+    class RequestId
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["REQUEST_ID"] = SecureRandom.uuid
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/shaf/registrable_factory.rb

@@ -0,0 +1,71 @@
+module Shaf
+  module RegistrableFactory
+
+    class NotFoundError < StandardError; end
+
+    def all
+      reg.dup
+    end
+
+    def size
+      reg.size
+    end
+
+    def register(clazz)
+      reg << clazz
+    end
+
+    def unregister(*str)
+      return if str.empty? || !str.all?
+      reg.delete_if { |clazz| matching_class? str, clazz }
+    end
+
+    def lookup(*str)
+      return if str.empty? || !str.all?
+      reg.detect { |clazz| matching_class? str, clazz }
+    end
+
+    def usage
+      reg.compact.map do |entry|
+        usage = entry.instance_eval { @usage }
+        usage.respond_to?(:call) ? usage.call : usage
+      end
+    end
+
+    def create(*params)
+      clazz = lookup(*params)
+      raise NotFoundError.new(%Q(Command '#{ARGV}' is not supported)) unless clazz
+
+      args = init_args(clazz, params)
+      clazz.new(*args)
+    end
+
+    private
+
+    def reg
+      @reg ||= []
+    end
+
+    def matching_class?(strings, clazz)
+      identifiers = clazz.instance_eval { @identifiers }
+      return false if strings.size < identifiers.size
+      identifiers.zip(strings).all? { |pattern, str| matching_identifier? str, pattern }
+    end
+
+    def matching_identifier?(str, pattern)
+      return false if pattern.nil? || str.nil? || str.empty?
+      pattern = pattern.to_s if pattern.is_a? Symbol
+      return str == pattern if pattern.is_a? String
+      str.match(pattern) || false
+    end
+
+    def identifier_count(clazz)
+      clazz.instance_eval { @identifiers }&.size || 0
+    end
+
+    def init_args(clazz, params)
+      first_non_id = identifier_count(clazz)
+      params[first_non_id..-1]
+    end
+  end
+end

data/lib/shaf/settings.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+
+module Shaf
+  class Settings
+    SETTINGS_FILE = 'config/settings.yml'
+
+    class << self
+      def load
+        @settings = File.exist?(SETTINGS_FILE) ?
+          YAML.load(File.read(SETTINGS_FILE)) : {}
+      end
+
+      def env
+        @env ||= (ENV['APP_ENV'] || ENV['RACK_ENV'] || :development).to_sym
+      end
+
+      def method_missing(method, *args)
+        load unless defined? @settings
+
+        define_singleton_method(method) do
+          @settings.dig(env.to_s, method.to_s)
+        end
+
+        return public_send(method)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        return true
+      end
+    end
+  end
+end

data/lib/shaf/spec.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'minitest/hooks'
+require 'shaf/spec/http_method_utils'
+require 'shaf/spec/payload_utils'
+require 'shaf/spec/integration_spec'
+require 'shaf/spec/serializer_spec'

data/lib/shaf/spec/http_method_utils.rb

@@ -0,0 +1,24 @@
+module Shaf
+  module Spec
+    module HttpMethodUtils
+      include ::Rack::Test::Methods
+
+      [:get, :put, :post, :delete].each do |m|
+        define_method m do |*args|
+          set_headers
+          super(*args)
+          set_payload parse_response(last_response.body)
+        end
+      end
+
+      def status
+        last_response&.status
+      end
+
+      def headers
+        last_response&.headers
+      end
+
+    end
+  end
+end

data/lib/shaf/spec/integration_spec.rb

@@ -0,0 +1,53 @@
+module Shaf
+  module Spec
+    class IntegrationSpec < Minitest::Spec
+      include Minitest::Hooks
+      include HttpMethodUtils
+      include PayloadUtils
+      include UriHelper
+
+      TRANSACTION_OPTIONS = {
+        rollback: :always,
+        savepoint: true,
+        auto_savepoint: true
+      }.freeze
+
+      register_spec_type self do |desc, args|
+        next unless args && args.is_a?(Hash)
+        args[:type]&.to_s == 'integration'
+      end
+
+      around do |&block|
+        DB.transaction(TRANSACTION_OPTIONS) { super(&block) }
+      end
+
+      def set_headers
+        if defined?(@__integration_test_auth_token) && @__integration_test_auth_token
+          header 'X-AUTH-TOKEN', @__integration_test_auth_token
+        end
+      end
+
+      def parse_response(body)
+        return nil if body.empty?
+        JSON.parse(body, symbolize_names: true)
+      end
+
+      def app
+        App.instance
+      end
+
+#       def login(email, pass)
+#         params = {email: email, password: pass}
+#         header 'Content-Type', 'application/json'
+#         post Shaf::UriHelper.session_uri, JSON.generate(params)
+#         @__integration_test_auth_token = attribute[:auth_token]
+#       end
+# 
+#       def logout
+#         delete Shaf::UriHelper.session_uri
+#         @__integration_test_auth_token = nil
+#       end
+
+    end
+  end
+end

data/lib/shaf/spec/model.rb

@@ -0,0 +1,17 @@
+module TestUtils
+  module Model
+    class Request
+      attr_reader :env
+
+      def env
+        @env ||= {}
+      end
+    end
+
+    module Test
+      def request
+        @request ||= Request.new
+      end
+    end
+  end
+end

data/lib/shaf/spec/payload_test.rb

@@ -0,0 +1,78 @@
+$:.unshift '.'
+require 'minitest/autorun'
+require 'test/test_utils/payload'
+
+class PayloadTest < Minitest::Test
+  include TestUtils::Payload
+
+  def setup
+    @payload = {
+      attr1: 1,
+      attr2: 2,
+      _links: {
+        link1: {
+          href: '/link1'
+        },
+        link2: {
+          href: '/link2'
+        }
+      },
+      _embedded: {
+        embed1: {
+          attr_e1: 'e1',
+          _links: {
+            link_e1: {
+              href: '/links/e1'
+            }
+          },
+          _embedded: {
+            embed1a: {
+              attr_e1a: 'e1a'
+            }
+          }
+        },
+        embed2: [
+          {
+            attr_embed2a: 'e2a',
+            _links: {
+              link_e2a: {
+                href: 'links/e2a'
+              }
+            }
+          },
+          {
+            attr_embed2b: 'e2b',
+            _links: {
+              link_e2b: {
+                href: 'links/e2b'
+              }
+            }
+          }
+        ]
+      }
+    }
+  end
+
+  #TODO How to verify that we do get assertions
+
+  def test_links
+    assert_link :link1, '/link1'
+    assert_link :link2, '/link2'
+  end
+
+  def test_embedded_without_block
+    assert_equal @payload[:_embedded], embedded
+    assert_equal @payload[:_embedded][:embed1], embedded(:embed1)
+  end
+
+  def test_embedded_with_block
+    embedded :embed1 do
+      assert_attribute :attr_e1, 'e1'
+      assert_link :link_e1, '/links/e1'
+
+      embedded :embed1a do
+        assert_attribute :attr_e1a, 'e1a'
+      end
+    end
+  end
+end

data/lib/shaf/spec/payload_utils.rb

@@ -0,0 +1,176 @@
+require 'minitest/assertions'
+
+module Shaf
+  module Spec
+    module PayloadUtils
+
+      class Embedded
+        include HttpMethodUtils
+        include PayloadUtils
+        include Minitest::Assertions
+
+        # This is needed by Minitest::Assertions
+        # And we need that module to have all assert_*/refute_* methods
+        # available in this class
+        attr_accessor :assertions
+
+        def initialize(payload, context, block)
+          @payload = payload
+          @context = context
+          @block = block
+          @assertions = 0
+        end
+
+        def call
+          instance_exec(&@block)
+        end
+
+        def method_missing(method, *args, &block)
+          if @context&.respond_to? method
+            define_singleton_method(method) { |*a, &b| @context.public_send method, *a, &b }
+            return public_send(method, *args, &block)
+          end
+          super
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          return true if @context&.respond_to? method
+          super
+        end
+
+      end
+
+      def set_payload(payload)
+        @payload = payload
+        @payload = JSON.parse(payload, symbolize_names: true) if payload.is_a?(String)
+      end
+
+      def last_payload
+        refute @payload.nil?, "No previous response body"
+        @payload
+      end
+
+      def attributes
+        last_payload.reject { |key,_| [:_links, :_embedded].include? key }
+      end
+
+      def links
+        last_payload[:_links] || []
+      end
+
+      def link_rels
+        links.keys
+      end
+
+      def embedded_resources
+        last_payload[:_embedded]&.keys || []
+      end
+
+      def embedded(name = nil)
+        assert_has_embedded name
+        keys = [:_embedded, name&.to_sym].compact
+        return last_payload.dig(*keys) unless block_given?
+        Embedded.new(last_payload.dig(*keys), self, Proc.new).call
+      end
+
+      def follow_rel(rel, method: nil)
+        assert_has_link(rel)
+        link = links[rel.to_sym]
+        if method && respond_to?(method)
+          public_send(method, link[:href])
+        else
+          get link[:href]
+        end
+      end
+
+      def fill_form(fields)
+        fields.map do |field|
+          value = case field[:type]
+                  when 'integer'
+                    field[:name].size
+                  when 'string'
+                    "value for #{field[:name]}"
+                  else
+                    "type not supported"
+                  end
+          [field[:name], value]
+        end.to_h
+      end
+
+      def assert_status(code)
+        assert_equal code, status,
+          "Response status was expected to be #{code}."
+      end
+
+      def assert_header(key, value)
+        assert_equal value, headers[key],
+          "Response was expected have header #{key} = #{value}."
+      end
+
+      def assert_has_attribute(attr)
+        assert last_payload[attr.to_sym],
+          "Response does not contain attribute '#{attr}': #{last_payload}"
+      end
+
+      def refute_has_attribute(attr)
+        refute last_payload[attr.to_sym],
+          "Response contains disallowed attribute '#{attr}': #{last_payload}"
+      end
+
+      def assert_has_attributes(*attrs)
+        attrs.each { |attr| assert_has_attribute(attr) }
+      end
+
+      def refute_has_attributes(*attrs)
+        attrs.each { |attr| refute_has_attribute(attr) }
+      end
+
+      def assert_attribute(attr, expected)
+        assert_has_attribute(attr)
+        assert_equal expected, last_payload[attr.to_sym]
+      end
+
+      def assert_has_link(rel)
+        assert last_payload.key?(:_links), "Response does not have any links: #{last_payload}"
+        assert last_payload[:_links][rel.to_sym],
+          "Response does not contain link with rel '#{rel}': #{last_payload}"
+        assert last_payload[:_links][rel.to_sym][:href],
+          "link with rel '#{rel}' in ressponse does not have a href: #{last_payload}"
+      end
+
+      def refute_has_link(rel)
+        refute last_payload.dig(:_links, rel.to_sym),
+          "Response contains disallowed link with rel '#{rel}': #{last_payload}"
+      end
+
+      def assert_has_links(*rels)
+        rels.each { |rel| assert_has_link(rel) }
+      end
+
+      def refute_has_links(*rels)
+        rels.each { |rel| refute_has_link(rel) }
+      end
+
+      def assert_link(rel, expected)
+        assert_has_link(rel)
+        assert_equal expected, last_payload.dig(:_links, rel.to_sym, :href)
+      end
+
+      def assert_has_embedded(*names)
+        names.each do |name|
+          assert last_payload.key?(:_embedded),
+            "Response does not have any embedded resources: #{last_payload}"
+          assert last_payload[:_embedded][name.to_sym],
+            "Response does not contain embedded resource with name '#{name}': #{last_payload}"
+        end
+      end
+
+      def refute_has_embedded(*names)
+        names.each do |name|
+          refute last_payload.dig(:_embedded, name.to_sym),
+            "Response contains disallowed embedded resource with name '#{name}': #{last_payload}"
+        end
+      end
+    end
+  end
+end