hanami 2.3.2 → 3.0.0

data/spec/unit/hanami/slice_configurable_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/app"
-require "hanami/slice_configurable"
-
-RSpec.describe Hanami::SliceConfigurable, :app_integration do
-  before do
-    module TestApp
-      class App < Hanami::App
-        register_slice :main
-        register_slice :admin
-      end
-
-      class BaseClass
-        extend Hanami::SliceConfigurable
-
-        def self.configure_for_slice(slice)
-          traces << slice
-        end
-
-        def self.traces
-          @traces ||= []
-        end
-
-        def self.inherited(subclass)
-          subclass.instance_variable_set(:@traces, traces.dup)
-          super
-        end
-      end
-    end
-  end
-
-  context "subclass inside slice namespace" do
-    before do
-      module Main
-        class MySubclass < TestApp::BaseClass; end
-      end
-    end
-
-    subject(:subclass) { Main::MySubclass }
-
-    it "calls `configure_for_slice` with the slice" do
-      expect(subclass.traces).to eq [Main::Slice]
-    end
-
-    context "further subclass, within same slice" do
-      before do
-        module Main
-          class MySubSubclass < Main::MySubclass; end
-        end
-      end
-
-      subject(:subclass) { Main::MySubSubclass }
-
-      it "does not call `configure_for_slice` again" do
-        expect(subclass.traces).to eq [Main::Slice]
-      end
-    end
-
-    context "further subclass, within another slice namespace" do
-      before do
-        module Admin
-          class MySubSubclass < Main::MySubclass; end
-        end
-      end
-
-      subject(:subclass) { Admin::MySubSubclass }
-
-      it "calls `configure_for_slice` with the other slice" do
-        expect(subclass.traces).to eq [Main::Slice, Admin::Slice]
-      end
-    end
-  end
-
-  context "subclass inside slice with name overlapping another slice" do
-    let(:app_modules) { super() << :ExternalAdmin }
-
-    before do
-      TestApp::App.register_slice :external_admin
-
-      module ExternalAdmin
-        class MySubclass < TestApp::BaseClass; end
-      end
-    end
-
-    subject(:subclass) { ExternalAdmin::MySubclass }
-
-    it "calls `configure_for_slice` with the correct matching slice" do
-      expect(subclass.traces).to eq [ExternalAdmin::Slice]
-    end
-  end
-
-  context "class inside app" do
-    before do
-      module TestApp
-        class MySubclass < TestApp::BaseClass; end
-      end
-    end
-
-    subject(:subclass) { TestApp::MySubclass }
-
-    it "calls `configure_for_slice` with the app instance" do
-      expect(subclass.traces).to eq [TestApp::App]
-    end
-
-    context "further subclass, within another slice namespace" do
-      before do
-        module Main
-          class MySubSubclass < TestApp::MySubclass; end
-        end
-      end
-
-      subject(:subclass) { Main::MySubSubclass }
-
-      it "calls `configure_for_slice` with the other slice" do
-        expect(subclass.traces).to eq [TestApp::App, Main::Slice]
-      end
-    end
-  end
-
-  context "subclass inside nested slice namespace" do
-    before do
-      module Main
-        class Slice
-          register_slice :nested
-        end
-
-        module Nested
-          class MySubclass < TestApp::BaseClass
-          end
-        end
-      end
-    end
-
-    subject(:subclass) { Main::Nested::MySubclass }
-
-    it "calls `configure_for_slice` with the nested slice" do
-      expect(subclass.traces).to eq [Main::Nested::Slice]
-    end
-  end
-end

data/spec/unit/hanami/slice_name_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/slice_name"
-
-require "dry/inflector"
-
-RSpec.describe Hanami::SliceName do
-  subject(:slice_name) { described_class.new(slice, inflector: -> { inflector }) }
-  let(:slice) { double(name: "Main::Slice") }
-  let(:inflector) { Dry::Inflector.new }
-
-  let(:slice_module) { Module.new }
-
-  before do
-    stub_const "Main", slice_module
-  end
-
-  describe "#name" do
-    it "returns the downcased, underscored string name of the module containing the slice" do
-      expect(slice_name.name).to eq "main"
-    end
-  end
-
-  describe "#to_s" do
-    it "returns the downcased, underscored string name of the module containing the slice" do
-      expect(slice_name.to_s).to eq "main"
-    end
-  end
-
-  describe "#to_sym" do
-    it "returns the downcased, underscored, symbolized name of the module containing the slice" do
-      expect(slice_name.to_sym).to eq :main
-    end
-  end
-
-  describe "#namespace_name" do
-    it "returns the string name of the module containing the slice" do
-      expect(slice_name.namespace_name).to eq "Main"
-    end
-  end
-
-  describe "#namespace_const" do
-    it "returns the module containing the slice" do
-      expect(slice_name.namespace).to be slice_module
-    end
-  end
-end

data/spec/unit/hanami/slice_spec.rb

@@ -1,99 +0,0 @@
-require "hanami/slice"
-
-RSpec.describe Hanami::Slice, :app_integration do
-  before do
-    module TestApp
-      class App < Hanami::App
-      end
-    end
-  end
-
-  describe ".app" do
-    subject(:slice) { Hanami.app.register_slice(:main) }
-
-    it "returns the top-level Hanami App slice" do
-      expect(slice.app).to eq Hanami.app
-    end
-  end
-
-  describe ".app?" do
-    it "returns true if the slice is Hanami.app" do
-      subject = Hanami.app
-      expect(subject.app?).to eq true
-    end
-
-    it "returns false if the slice is not Hanami.app" do
-      subject = Hanami.app.register_slice(:main)
-      expect(subject.app?).to eq false
-    end
-  end
-
-  describe ".environment" do
-    subject(:slice) { Hanami.app.register_slice(:main) }
-
-    before do
-      allow(slice.config).to receive(:env) { :development }
-    end
-
-    it "evaluates the block with the env matches the Hanami.env" do
-      expect {
-        slice.environment(:development) do
-          config.logger.level = :info
-        end
-      }
-        .to change { slice.config.logger.level }
-        .to :info
-    end
-
-    it "yields the slice to the block" do
-      captured_slice = nil
-      slice.environment(:development) { |slice| captured_slice = slice }
-      expect(captured_slice).to be slice
-    end
-
-    it "does not evaluate the block with the env does not match the Hanami.env" do
-      expect {
-        slice.environment(:test) do
-          config.logger.level = :info
-        end
-      }.not_to(change { slice.config.logger.level })
-    end
-  end
-
-  describe ".prepare" do
-    it "raises an error if the slice class is anonymous" do
-      expect { Class.new(described_class).prepare }
-        .to raise_error Hanami::SliceLoadError, /Slice must have a class name/
-    end
-
-    it "does not allow special characters in slice names" do
-      expect { Hanami.app.register_slice(:'test_$lice') }
-        .to raise_error(ArgumentError, /must be lowercase alphanumeric text and underscores only/)
-    end
-
-    it "does not allow uppercase characters in slice names" do
-      expect { Hanami.app.register_slice(:TEST_slice) }
-        .to raise_error(ArgumentError, /must be lowercase alphanumeric text and underscores only/)
-    end
-
-    it "allows lowercase alphanumeric text and underscores only" do
-      expect { Hanami.app.register_slice(:test_slice) }.not_to raise_error
-    end
-
-    it "allows single character slice names" do
-      expect { Hanami.app.register_slice(:t) }.not_to raise_error
-    end
-  end
-
-  describe ".source_path" do
-    it "provides a path to the app directory for Hanami.app" do
-      subject = Hanami.app
-      expect(subject.source_path).to eq Hanami.app.root.join("app")
-    end
-
-    it "provides a path to the slice root for a Slice" do
-      subject = Hanami.app.register_slice(:main)
-      expect(subject.source_path).to eq subject.root
-    end
-  end
-end

data/spec/unit/hanami/web/rack_logger_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/web/rack_logger"
-require "dry/logger"
-require "stringio"
-require "rack/mock"
-
-RSpec.describe Hanami::Web::RackLogger do
-  subject { described_class.new(logger) }
-
-  let(:logger) do
-    Dry.Logger(
-      app_name,
-      stream: stream,
-      level: :debug,
-      filters: filters,
-      formatter: :rack,
-      template: "[%<progname>s] [%<severity>s] [%<time>s] %<message>s"
-    )
-  end
-
-  let(:stream) { StringIO.new }
-  let(:filters) { ["user.password"] }
-  let(:app_name) { "my_app" }
-
-  describe "#initialize" do
-    it "returns an instance of #{described_class}" do
-      expect(subject).to be_kind_of(described_class)
-    end
-  end
-
-  describe "#log_request" do
-    it "logs current request" do
-      time = Time.parse("2022-02-04 11:38:25.218816 +0100")
-      expect(Time).to receive(:now).at_least(:once).and_return(time)
-
-      path = "/users"
-      ip = "127.0.0.1"
-      status = 200
-      elapsed = 0.0001
-      content_length = 23
-      verb = "POST"
-
-      env = Rack::MockRequest.env_for(path, method: verb)
-      env["CONTENT_LENGTH"] = content_length
-      env["REMOTE_ADDR"] = ip
-
-      params = {"user" => {"password" => "secret"}}
-      env["router.params"] = params
-
-      subject.log_request(env, status, elapsed)
-
-      stream.rewind
-      actual = stream.read
-
-      if RUBY_VERSION < "3.4"
-        expect(actual).to eql(<<~LOG)
-          [#{app_name}] [INFO] [#{time}] #{verb} #{status} #{elapsed}µs #{ip} #{path} #{content_length}
-            {"user"=>{"password"=>"[FILTERED]"}}
-        LOG
-      else
-        expect(actual).to eql(<<~LOG)
-          [#{app_name}] [INFO] [#{time}] #{verb} #{status} #{elapsed}µs #{ip} #{path} #{content_length}
-            {"user" => {"password" => "[FILTERED]"}}
-        LOG
-      end
-    end
-
-    context "ip" do
-      it "takes into account HTTP proxy forwarding" do
-        env = Rack::MockRequest.env_for("/")
-        env["REMOTE_ADDR"] = remote = "127.0.0.1"
-        env["HTTP_X_FORWARDED_FOR"] = forwarded = "::1"
-
-        subject.log_request(env, 200, 0.1)
-
-        stream.rewind
-        actual = stream.read
-
-        expect(actual).to include(forwarded)
-        expect(actual).to_not include(remote)
-      end
-    end
-
-    context "path prefix" do
-      it "logs full referenced relative path" do
-        env = Rack::MockRequest.env_for(path = "/users")
-        env["SCRIPT_NAME"] = script_name = "/v1"
-
-        subject.log_request(env, 200, 0.1)
-
-        stream.rewind
-        actual = stream.read
-
-        expect(actual).to include(script_name + path)
-      end
-    end
-  end
-end