hanami 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/cli/plugins_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-RSpec.describe "CLI plugins", type: :integration do
-  xit "includes its commands in CLI output" do
-    with_project do
-      bundle_exec "hanami"
-      expect(out).to include("hanami plugin [SUBCOMMAND]")
-    end
-  end
-
-  xit "executes command from plugin" do
-    with_project do
-      bundle_exec "hanami plugin version"
-      expect(out).to include("v0.1.0")
-    end
-  end
-
-  # See https://github.com/hanami/hanami/issues/838
-  it "guarantees 'hanami new' to generate a project" do
-    project = "bookshelf_without_gemfile"
-
-    with_system_tmp_directory do
-      run_cmd_with_clean_env "hanami new #{project}"
-      destination = Pathname.new(Dir.pwd).join(project)
-
-      expect(destination).to exist
-    end
-  end
-
-  private
-
-  def with_project
-    super("bookshelf", gems: { "hanami-plugin" => { groups: [:plugins], path: Pathname.new(__dir__).join("..", "..", "..", "spec", "support", "fixtures", "hanami-plugin").realpath.to_s } }) do
-      yield
-    end
-  end
-end

data/spec/integration/cli/routes_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "hanami routes", type: :integration do
-  it "prints app routes" do
-    with_project do
-      generate "app admin"
-
-      write "lib/ping.rb", <<~EOF
-        class Ping
-          def call(env)
-            [200, {}, ["PONG"]]
-          end
-        end
-      EOF
-
-      unshift "config/environment.rb", "require_relative '../lib/ping'"
-      replace "config/environment.rb", "Hanami.configure do", "Hanami.configure do\nmount Ping, at: '/ping'"
-
-      generate "action web home#index --url=/"
-      generate "action web books#create --url=/books --method=POST"
-
-      generate "action admin home#index --url=/"
-
-      hanami "routes"
-
-      expect(out).to eq "Name Method     Path                           Action                        \n\n                                /ping                          Ping                          \n\n                Name Method     Path                           Action                        \n\n                     GET, HEAD  /admin                         Admin::Controllers::Home::Index\n\n                Name Method     Path                           Action                        \n\n                     GET, HEAD  /                              Web::Controllers::Home::Index \n                     POST       /books                         Web::Controllers::Books::Create"
-    end
-  end
-
-  it "prints help message" do
-    with_project do
-      output = <<~OUT
-Command:
-  hanami routes
-
-Usage:
-  hanami routes
-
-Description:
-  Prints routes
-
-Options:
-  --help, -h                        # Print this help
-OUT
-
-      run_cmd 'hanami routes --help', output
-    end
-  end
-end

data/spec/integration/cli/server_spec.rb

@@ -1,626 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-RSpec.describe "hanami server", type: :integration do
-  context "without routes" do
-    it "shows welcome page" do
-      with_project do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-
-          expect(page).to have_content("The web, with simplicity.")
-          expect(page).to have_content("Hanami is Open Source Software for MVC web development with Ruby.")
-          expect(page).to have_content("bundle exec hanami generate action web 'home#index' --url=/")
-        end
-      end
-    end
-
-    it "shows welcome page for generated app" do
-      with_project do
-        generate "app admin"
-
-        server do
-          visit "/admin"
-
-          expect(page).to have_content("bundle exec hanami generate action admin 'home#index' --url=/")
-        end
-      end
-    end
-  end
-
-  context "with routes" do
-    it "serves action" do
-      with_project do
-        server do
-          generate "action web home#index --url=/"
-
-          visit "/"
-          expect(page).to have_title("Web")
-        end
-      end
-    end
-
-    it "serves static asset" do
-      with_project do
-        server do
-          write "apps/web/assets/javascripts/app.js", <<~EOF
-            console.log('test');
-          EOF
-          visit "/assets/app.js"
-          expect(page).to have_content("console.log('test');")
-        end
-      end
-    end
-
-    it "serves contents from database" do
-      with_project do
-        setup_model
-        console do |input, _, _|
-          input.puts("BookRepository.new.create(title: 'Learn Hanami')")
-          input.puts("exit")
-        end
-
-        generate "action web books#show --url=/books/:id"
-        rewrite  "apps/web/controllers/books/show.rb", <<~EOF
-          module Web::Controllers::Books
-            class Show
-              include Web::Action
-              expose :book
-
-              def call(params)
-                @book = BookRepository.new.find(params[:id]) or halt(404)
-              end
-            end
-          end
-        EOF
-        rewrite "apps/web/templates/books/show.html.erb", <<~EOF
-          <h1><%= book.title %></h1>
-        EOF
-
-        server do
-          visit "/books/1"
-          expect(page).to have_content("Learn Hanami")
-        end
-      end
-    end
-  end
-
-  context "logging" do
-    let(:log)     { "log/development.log" }
-    let(:project) { "bookshelf" }
-
-    context "when enabled" do
-      it "logs GET requests" do
-        with_project(project) do
-          touch log
-          replace "config/environment.rb", "logger level: :debug", %(logger level: :debug, stream: "#{log}")
-
-          server do
-            visit "/"
-            expect(page).to have_title("Hanami | The web, with simplicity")
-          end
-
-          content = contents(log)
-          expect(content).to include("[#{project}] [INFO]")
-          expect(content).to match(%r{HTTP/1.1 GET 200 (.*) /})
-        end
-      end
-
-      it "logs GET requests with query string" do
-        with_project(project) do
-          touch log
-          replace "config/environment.rb", "logger level: :debug", %(logger level: :debug, stream: "#{log}")
-
-          run_cmd "hanami generate action web home#index --url=/", []
-
-          server do
-            visit "/?ping=pong"
-            expect(page).to have_title("Web")
-          end
-
-          content = contents(log)
-          expect(content).to include("[#{project}] [INFO]")
-          expect(content).to match(%({"ping"=>"pong"}))
-        end
-      end
-
-      it "logs non-GET requests with payload" do
-        with_project(project) do
-          touch log
-          replace "config/environment.rb", "logger level: :debug", %(logger level: :debug, stream: "#{log}")
-
-          run_cmd "hanami generate action web books#create --method=POST", []
-
-          server do
-            post "/books", book: { title: "Functions" }
-          end
-
-          content = contents(log)
-          expect(content).to include("[#{project}] [INFO]")
-          expect(content).to match(%({"book"=>{"title"=>"Functions"}}))
-        end
-      end
-
-      it "logs non-GET requests from body parsers" do
-        with_project(project) do
-          touch log
-          replace "config/environment.rb", "logger level: :debug", %(logger level: :debug, stream: "#{log}")
-          inject_line_after "config/environment.rb", "Hanami.configure", "require 'hanami/middleware/body_parser'\nmiddleware.use Hanami::Middleware::BodyParser, :json"
-
-          run_cmd "hanami generate action web books#create --method=POST", []
-          inject_line_after "apps/web/controllers/books/create.rb", "call", 'Hanami.logger.debug(request.env["CONTENT_TYPE"]);self.body = %({"status":"OK"})'
-
-          server do
-            post "/books", book: { title: "Why we sleep" }
-            post "/books", JSON.generate(book: { title: "Parsers" }), "CONTENT_TYPE" => "app/json", "HTTP_ACCEPT" => "app/json"
-            post "/books", JSON.generate(%w[this is cool]), "CONTENT_TYPE" => "app/json", "HTTP_ACCEPT" => "app/json"
-          end
-
-          content = contents(log)
-          expect(content).to include("[#{project}] [INFO]")
-          expect(content).to include("POST 200")
-
-          expect(content).to include("app/x-www-form-urlencoded")
-          expect(content).to include(%({"book"=>{"title"=>"Why we sleep"}}))
-
-          expect(content).to include("app/json")
-          expect(content).to include(%({"book"=>{"title"=>"Parsers"}}))
-          expect(content).to include(%({"_"=>["this", "is", "cool"]}))
-        end
-      end
-    end
-
-    context "when not enabled" do
-      it "does not log request" do
-        with_project(project) do
-          replace "config/environment.rb", "logger level: :debug", ""
-
-          server do
-            visit "/"
-          end
-
-          expect(log).to_not be_an_existing_file
-        end
-      end
-    end
-  end
-
-  context "--host" do
-    it "starts on given host" do
-      with_project do
-        server(host: "127.0.0.1") do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-
-    xit "fails when missing" do
-      with_project do
-        server(host: nil)
-
-        expect(exitstatus).to eq(1)
-      end
-    end
-  end
-
-  context "--port" do
-    it "starts on given port" do
-      with_project do
-        server(port: 1982) do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-
-    xit "fails when missing" do
-      with_project do
-        server(port: nil)
-
-        expect(exitstatus).to eq(1)
-      end
-    end
-  end
-
-  context "environment" do
-    it "starts with given environment" do
-      with_project do
-        generate "action web home#index --url=/"
-
-        rewrite "apps/web/controllers/home/index.rb", <<~EOF
-          module Web::Controllers::Home
-            class Index
-              include Web::Action
-
-              def call(params)
-                self.body = Hanami.env
-              end
-            end
-          end
-        EOF
-
-        RSpec::Support::Env["HANAMI_ENV"]   = env = "production"
-        RSpec::Support::Env["DATABASE_URL"] = "sqlite://#{Pathname.new('db').join('bookshelf.sqlite')}"
-        RSpec::Support::Env["SMTP_HOST"]    = "localhost"
-        RSpec::Support::Env["SMTP_PORT"]    = "25"
-
-        server do
-          visit "/"
-
-          expect(page).to have_content(env)
-        end
-      end
-    end
-
-    xit "fails when missing" do
-      with_project do
-        server(environment: nil)
-
-        expect(exitstatus).to eq(1)
-      end
-    end
-  end
-
-  context "puma" do
-    it "starts" do
-      with_project("bookshelf_server_puma", server: :puma) do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-  end
-
-  context "unicorn" do
-    it "starts" do
-      with_project("bookshelf_server_unicorn", server: :unicorn) do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-  end
-
-  context "code reloading" do
-    it "reloads templates code" do
-      with_project do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-          generate "action web home#index --url=/"
-
-          rewrite "apps/web/templates/home/index.html.erb", <<~EOF
-            <h1>Hello, World!</h1>
-          EOF
-
-          visit "/"
-          expect(page).to have_title("Web")
-          expect(page).to have_content("Hello, World!")
-        end
-      end
-    end
-
-    it "reloads view" do
-      with_project do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-          generate "action web home#index --url=/"
-
-          rewrite "apps/web/views/home/index.rb", <<~EOF
-            module Web::Views::Home
-              class Index
-                include Web::View
-
-                def greeting
-                  "Ciao!"
-                end
-              end
-            end
-          EOF
-
-          rewrite "apps/web/templates/home/index.html.erb", <<~EOF
-            <%= greeting %>
-          EOF
-
-          visit "/"
-          expect(page).to have_title("Web")
-          expect(page).to have_content("Ciao!")
-        end
-      end
-    end
-
-    it "reloads action" do
-      with_project do
-        server do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-          generate "action web home#index --url=/"
-
-          rewrite "apps/web/controllers/home/index.rb", <<~EOF
-            module Web::Controllers::Home
-              class Index
-                include Web::Action
-
-                def call(params)
-                  self.body = "Hi!"
-                end
-              end
-            end
-          EOF
-
-          visit "/"
-          expect(page).to have_content("Hi!")
-        end
-      end
-    end
-
-    it "reloads model" do
-      project_name = "bookshelf"
-
-      with_project(project_name) do
-        # STEP 1: prepare the database and the repository
-        generate_model "user"
-        generate_migration "create_users", <<~EOF
-          Hanami::Model.migration do
-            change do
-              create_table :users do
-                primary_key :id
-                column :name, String
-              end
-
-              execute "INSERT INTO users (name) VALUES('L')"
-              execute "INSERT INTO users (name) VALUES('MG')"
-            end
-          end
-        EOF
-
-        rewrite "lib/#{project_name}/repositories/user_repository.rb", <<~EOF
-          class UserRepository < Hanami::Repository
-            def listing
-              all
-            end
-          end
-        EOF
-
-        hanami "db prepare"
-
-        # STEP 2: generate the action
-        generate "action web users#index --url=/users"
-
-        rewrite "apps/web/controllers/users/index.rb", <<~EOF
-          module Web::Controllers::Users
-            class Index
-              include Web::Action
-
-              def call(params)
-                self.body = UserRepository.new.listing.map(&:name).join(", ")
-              end
-            end
-          end
-        EOF
-
-        server do
-          # STEP 3: visit the page
-          visit "/users"
-
-          expect(page).to have_content("L, MG")
-
-          # STEP 4: change the repository, then visit the page again
-          rewrite "lib/#{project_name}/repositories/user_repository.rb", <<~EOF
-            class UserRepository < Hanami::Repository
-              def listing
-                all.reverse
-              end
-            end
-          EOF
-          visit "/users"
-
-          expect(page).to have_content("MG, L")
-        end
-      end
-    end
-
-    xit "reloads asset" do
-      with_project do
-        server do
-          write "apps/web/assets/stylesheets/style.css", <<~EOF
-            body { background-color: #fff; }
-          EOF
-
-          visit "/assets/style.css"
-          expect(page).to have_content("#fff")
-
-          rewrite "apps/web/assets/stylesheets/style.css", <<~EOF
-            body { background-color: #333; }
-          EOF
-
-          visit "/assets/style.css"
-          expect(page).to have_content("#333")
-        end
-      end
-    end
-  end
-
-  context "without code reloading" do
-    it "doesn't reload code" do
-      with_project do
-        server("no-code-reloading" => nil) do
-          visit "/"
-
-          expect(page).to have_title("Hanami | The web, with simplicity")
-          generate "action web home#index --url=/"
-
-          visit "/"
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-  end
-
-  context "without hanami model" do
-    it "uses custom model domain" do
-      project_without_hanami_model("bookshelf", gems: ["dry-struct"]) do
-        write "lib/entities/access_token.rb", <<~EOF
-          require 'dry-struct'
-          require 'securerandom'
-
-          module Types
-            include Dry::Types.module
-          end
-
-          class AccessToken < Dry::Struct
-            attribute :id,     Types::String.default { SecureRandom.uuid }
-            attribute :secret, Types::String
-            attribute :digest, Types::String
-          end
-        EOF
-        generate "action web access_tokens#show --url=/access_tokens/:id"
-        rewrite  "apps/web/controllers/access_tokens/show.rb", <<~EOF
-          module Web::Controllers::AccessTokens
-            class Show
-              include Web::Action
-              expose :access_token
-
-              def call(params)
-                @access_token = AccessToken.new(id: '1', secret: 'shh', digest: 'abc')
-              end
-            end
-          end
-        EOF
-        rewrite "apps/web/templates/access_tokens/show.html.erb", <<~EOF
-          <h1><%= access_token.secret %></h1>
-        EOF
-
-        server do
-          visit "/access_tokens/1"
-          visit "/access_tokens/1" # forces code reloading
-          expect(page).to have_content("shh")
-        end
-      end
-    end
-  end
-
-  context "without mailer" do
-    it "returns page" do
-      with_project do
-        remove_block "config/environment.rb", "mailer do"
-
-        server do
-          visit "/"
-          expect(page).to have_title("Hanami | The web, with simplicity")
-        end
-      end
-    end
-  end
-
-  it "prints help message" do
-    with_project do
-      output = <<-OUT
-Command:
-  hanami server
-
-Usage:
-  hanami server
-
-Description:
-  Start Hanami server (only for development)
-
-Options:
-  --server=VALUE                    # Force a server engine (eg, webrick, puma, thin, etc..)
-  --host=VALUE                      # The host address to bind to
-  --port=VALUE, -p VALUE            # The port to run the server on
-  --debug=VALUE                     # Turn on debug output
-  --warn=VALUE                      # Turn on warnings
-  --daemonize=VALUE                 # Daemonize the server
-  --pid=VALUE                       # Path to write a pid file after daemonize
-  --[no-]code-reloading             # Code reloading, default: true
-  --help, -h                        # Print this help
-
-Examples:
-  hanami server                     # Basic usage (it uses the bundled server engine)
-  hanami server --server=webrick    # Force `webrick` server engine
-  hanami server --host=0.0.0.0      # Bind to a host
-  hanami server --port=2306         # Bind to a port
-  hanami server --no-code-reloading # Disable code reloading
-OUT
-
-      run_cmd 'hanami server --help', output
-    end
-  end
-
-  context "with HANAMI_APPS ENV variable" do
-    it "loads only specific app" do
-      with_project do
-        generate "app admin"
-
-        remove_line "config/environment.rb", "require_relative '../apps/admin/app'"
-        remove_line "config/environment.rb", "mount Admin::App"
-
-        remove_line "config/environment.rb", "require_relative '../apps/web/app'"
-        remove_line "config/environment.rb", "mount Web::App"
-
-        inject_line_after "config/environment.rb", "Hanami.configure", <<-EOL
-  if Hanami.app?(:admin)
-    require_relative '../apps/admin/app'
-    mount Admin::App, at: '/admin'
-  end
-
-  if Hanami.app?(:web)
-    require_relative '../apps/web/app'
-    mount Web::App, at: '/'
-  end
-        EOL
-        generate "action web home#index --url=/"
-
-        rewrite "apps/web/controllers/home/index.rb", <<~EOF
-          module Web::Controllers::Home
-            class Index
-              include Web::Action
-
-              def call(params)
-                self.body = "app: web"
-              end
-            end
-          end
-        EOF
-        generate "action admin home#index --url=/"
-
-        rewrite "apps/admin/controllers/home/index.rb", <<~EOF
-          module Web::Controllers::Home
-            class Index
-              include Admin::Action
-
-              def call(params)
-                self.body = "app: admin"
-              end
-            end
-          end
-        EOF
-
-        RSpec::Support::Env["HANAMI_APPS"] = "web"
-
-        server do
-          visit "/"
-          expect(page).to have_content("app: web")
-
-          visit "/admin"
-          expect(page).to have_content("Not Found")
-        end
-      end
-    end
-  end
-end