power_api 0.1.0

data/spec/dummy/spec/lib/power_api/generator_helper/pagination_helper_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe PowerApi::GeneratorHelper::PaginationHelper, type: :generator do
+  describe "#api_pagination_initializer_path" do
+    let(:expected_path) { "config/initializers/api_pagination.rb" }
+
+    def perform
+      generators_helper.api_pagination_initializer_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "api_pagination_initializer_tpl" do
+    let(:template) do
+      <<~API_PAGINATION
+        ApiPagination.configure do |config|
+          # If you have more than one gem included, you can choose a paginator.
+          config.paginator = :kaminari
+
+          # By default, this is set to 'Total'
+          config.total_header = 'X-Total'
+
+          # By default, this is set to 'Per-Page'
+          config.per_page_header = 'X-Per-Page'
+
+          # Optional: set this to add a header with the current page number.
+          config.page_header = 'X-Page'
+
+          # Optional: set this to add other response format. Useful with tools that define :jsonapi format
+          # config.response_formats = [:json, :xml, :jsonapi]
+          config.response_formats = [:jsonapi]
+
+          # Optional: what parameter should be used to set the page option
+          config.page_param do |params|
+            params[:page][:number] if params[:page].is_a?(ActionController::Parameters)
+          end
+
+          # Optional: what parameter should be used to set the per page option
+          config.per_page_param do |params|
+            params[:page][:size] if params[:page].is_a?(ActionController::Parameters)
+          end
+
+          # Optional: Include the total and last_page link header
+          # By default, this is set to true
+          # Note: When using kaminari, this prevents the count call to the database
+          config.include_total = true
+        end
+      API_PAGINATION
+    end
+
+    def perform
+      generators_helper.api_pagination_initializer_tpl
+    end
+
+    it { expect(perform).to eq(template) }
+  end
+end

data/spec/dummy/spec/lib/power_api/generator_helper/resource_helper_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe PowerApi::GeneratorHelper::ResourceHelper, type: :generator do
+  describe "#resource" do
+    let(:resource) { generators_helper.resource }
+
+    it_behaves_like('ActiveRecord resource')
+    it_behaves_like('ActiveRecord resource attributes', :resource_attributes)
+  end
+
+  describe "#parent_resource" do
+    let(:parent_resource_name) { "blog" }
+    let(:resource) { generators_helper.parent_resource }
+
+    it_behaves_like('ActiveRecord resource')
+  end
+
+  describe "#parent_resource?" do
+    let(:parent_resource_name) { "blog" }
+
+    def perform
+      generators_helper.parent_resource?
+    end
+
+    it { expect(perform).to eq(true) }
+
+    context "with no parent resource name" do
+      let(:parent_resource_name) { nil }
+
+      it { expect(perform).to eq(false) }
+    end
+  end
+end

data/spec/dummy/spec/lib/power_api/generator_helper/routes_helper_spec.rb

@@ -0,0 +1,179 @@
+RSpec.describe PowerApi::GeneratorHelper::RoutesHelper, type: :generator do
+  describe "#routes_path" do
+    let(:expected_path) { "config/routes.rb" }
+
+    def perform
+      generators_helper.routes_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#api_version_routes_line_regex" do
+    let(:expected_regex) { /Api::V1[^\n]*/ }
+
+    def perform
+      generators_helper.api_version_routes_line_regex
+    end
+
+    it { expect(perform).to eq(expected_regex) }
+  end
+
+  describe "#parent_resource_routes_line_regex" do
+    def perform
+      generators_helper.parent_resource_routes_line_regex
+    end
+
+    it { expect { perform }.to raise_error("missing parent_resource") }
+
+    context "with parent_resource" do
+      let(:expected_regex) { /resources :users[^\n]*/ }
+      let(:parent_resource_name) { "user" }
+
+      it { expect(perform).to eq(expected_regex) }
+    end
+  end
+
+  describe "#resource_route_tpl" do
+    let(:actions) { [] }
+    let(:expected_tpl) { "resources :blogs" }
+    let(:parent_resource_name) { "user" }
+    let(:is_parent) { false }
+
+    def perform
+      generators_helper.resource_route_tpl(actions: actions, is_parent: is_parent)
+    end
+
+    it { expect(perform).to eq(expected_tpl) }
+
+    context "with specific actions" do
+      let(:actions) { ["index", "create"] }
+      let(:expected_tpl) { "resources :blogs, only: [:index, :create]" }
+
+      it { expect(perform).to eq(expected_tpl) }
+    end
+
+    context "with is_parent option actions" do
+      let(:is_parent) { true }
+      let(:expected_tpl) { "resources :users" }
+
+      it { expect(perform).to eq(expected_tpl) }
+    end
+  end
+
+  describe "routes_line_to_inject_new_version" do
+    let(:expected_line) do
+      "routes.draw do\n"
+    end
+
+    def perform
+      generators_helper.routes_line_to_inject_new_version
+    end
+
+    it { expect(perform).to eq(expected_line) }
+
+    context "when is not the first version" do
+      let(:version_number) { "2" }
+
+      let(:expected_line) do
+        "'/api' do\n"
+      end
+
+      it { expect(perform).to eq(expected_line) }
+    end
+  end
+
+  describe "#version_route_tpl" do
+    let(:expected_tpl) do
+      <<~ROUTE
+        scope path: '/api' do
+        api_version(module: 'Api::V1', path: { value: 'v1' }, defaults: { format: 'json' }) do
+        end
+        end
+      ROUTE
+    end
+
+    def perform
+      generators_helper.version_route_tpl
+    end
+
+    it { expect(perform).to eq(expected_tpl) }
+
+    context "when is not the first version" do
+      let(:version_number) { "2" }
+
+      let(:expected_tpl) do
+        <<~ROUTE
+          api_version(module: 'Api::V2', path: { value: 'v2' }, defaults: { format: 'json' }) do
+          end
+        ROUTE
+      end
+
+      it { expect(perform).to eq(expected_tpl.delete_suffix("\n")) }
+    end
+  end
+
+  describe "#parent_route_exist?" do
+    let(:parent_resource_name) { "user" }
+    let(:line) { nil }
+
+    def perform
+      generators_helper.parent_route_exist?
+    end
+
+    before { mock_file_content("config/routes.rb", [line]) }
+
+    context "with file line not matching regex" do
+      let(:line) { "X" }
+
+      it { expect(perform).to eq(false) }
+    end
+
+    context "with no parent_resource" do
+      let(:parent_resource_name) { nil }
+
+      it { expect { perform }.to raise_error("missing parent_resource") }
+    end
+
+    context "with file line matching regex" do
+      let(:line) { "resources :users" }
+
+      it { expect(perform).to eq(true) }
+    end
+  end
+
+  describe "#parent_route_already_have_children?" do
+    let(:parent_resource_name) { "user" }
+    let(:line) { nil }
+
+    def perform
+      generators_helper.parent_route_already_have_children?
+    end
+
+    before { mock_file_content("config/routes.rb", [line]) }
+
+    context "with file line not matching regex" do
+      let(:line) { "X" }
+
+      it { expect(perform).to eq(false) }
+    end
+
+    context "with no parent_resource" do
+      let(:parent_resource_name) { nil }
+
+      it { expect { perform }.to raise_error("missing parent_resource") }
+    end
+
+    context "with parent line found but with no children" do
+      let(:line) { "resources :users" }
+
+      it { expect(perform).to eq(false) }
+    end
+
+    context "with parent line found with children" do
+      let(:line) { "resources :users do" }
+
+      it { expect(perform).to eq(true) }
+    end
+  end
+end

data/spec/dummy/spec/lib/power_api/generator_helper/simple_token_auth_helper_spec.rb

@@ -0,0 +1,164 @@
+RSpec.describe PowerApi::GeneratorHelper::SimpleTokenAuthHelper, type: :generator do
+  describe "#authenticated_resource" do
+    let(:authenticated_resource) { "blog" }
+    let(:resource) { generators_helper.authenticated_resource }
+
+    it_behaves_like('ActiveRecord resource') do
+      describe "#authenticated_resources_migrations" do
+        let(:expected) do
+          "migration add_authentication_token_to_blogs authentication_token:string{30}:uniq"
+        end
+
+        it { expect(resource.authenticated_resource_migration).to eq(expected) }
+      end
+
+      describe "current_authenticated_resource" do
+        it { expect(generators_helper.current_authenticated_resource).to eq("current_blog") }
+      end
+    end
+  end
+
+  describe "#authenticated_resources=" do
+    let(:resources_names) { ["blog"] }
+    let(:resource) { resources.first }
+
+    def resources
+      generators_helper.authenticated_resources = resources_names
+      generators_helper.authenticated_resources
+    end
+
+    it { expect(resources.count).to eq(1) }
+    it { expect(resources.first).to be_a(described_class::SimpleTokenAuthResource) }
+
+    it_behaves_like('ActiveRecord resource') do
+      describe "#authenticated_resources_migrations" do
+        let(:expected) do
+          "migration add_authentication_token_to_blogs authentication_token:string{30}:uniq"
+        end
+
+        it { expect(resource.authenticated_resource_migration).to eq(expected) }
+      end
+    end
+  end
+
+  describe "#owned_by_authenticated_resource?" do
+    let(:authenticated_resource) { "user" }
+    let(:owned_by_authenticated_resource) { true }
+    let(:parent_resource_name) { nil }
+
+    def perform
+      generators_helper.owned_by_authenticated_resource?
+    end
+
+    it { expect(perform).to eq(true) }
+
+    context "with no authenticated_resource" do
+      let(:authenticated_resource) { nil }
+
+      it { expect(perform).to eq(false) }
+    end
+
+    context "with no owned_by_authenticated_resource" do
+      let(:owned_by_authenticated_resource) { false }
+
+      it { expect(perform).to eq(false) }
+    end
+
+    context "with no parent_resource_name" do
+      let(:parent_resource_name) { "portfolio" }
+
+      it { expect(perform).to eq(false) }
+    end
+  end
+
+  describe "#simple_token_auth_method" do
+    let(:expected) do
+      "  acts_as_token_authenticatable\n\n"
+    end
+
+    it { expect(generators_helper.simple_token_auth_method).to eq(expected) }
+  end
+
+  describe "#simple_token_auth_initializer_path" do
+    let(:expected_path) { "spec/swagger/.gitkeep" }
+
+    def perform
+      generators_helper.simple_token_auth_initializer_path
+    end
+
+    it { expect(perform).to eq("config/initializers/simple_token_authentication.rb") }
+  end
+
+  describe "#simple_token_auth_initializer_tpl" do
+    let(:expected) do
+      <<~INITIALIZER
+        SimpleTokenAuthentication.configure do |config|
+          # Configure the session persistence policy after a successful sign in,
+          # in other words, if the authentication token acts as a signin token.
+          # If true, user is stored in the session and the authentication token and
+          # email may be provided only once.
+          # If false, users must provide their authentication token and email at every request.
+          # config.sign_in_token = false
+
+          # Configure the name of the HTTP headers watched for authentication.
+          #
+          # Default header names for a given token authenticatable entity follow the pattern:
+          #   { entity: { authentication_token: 'X-Entity-Token', email: 'X-Entity-Email'} }
+          #
+          # When several token authenticatable models are defined, custom header names
+          # can be specified for none, any, or all of them.
+          #
+          # Note: when using the identifiers options, this option behaviour is modified.
+          # Please see the example below.
+          #
+          # Examples
+          #
+          #   Given User and SuperAdmin are token authenticatable,
+          #   When the following configuration is used:
+          #     `config.header_names = { super_admin: { authentication_token: 'X-Admin-Auth-Token' } }`
+          #   Then the token authentification handler for User watches the following headers:
+          #     `X-User-Token, X-User-Email`
+          #   And the token authentification handler for SuperAdmin watches the following headers:
+          #     `X-Admin-Auth-Token, X-SuperAdmin-Email`
+          #
+          #   When the identifiers option is set:
+          #     `config.identifiers = { super_admin: :phone_number }`
+          #   Then both the header names identifier key and default value are modified accordingly:
+          #     `config.header_names = { super_admin: { phone_number: 'X-SuperAdmin-PhoneNumber' } }`
+          #
+          # config.header_names = { user: { authentication_token: 'X-User-Token', email: 'X-User-Email' } }
+
+          # Configure the name of the attribute used to identify the user for authentication.
+          # That attribute must exist in your model.
+          #
+          # The default identifiers follow the pattern:
+          # { entity: 'email' }
+          #
+          # Note: the identifer must match your Devise configuration,
+          # see https://github.com/plataformatec/devise/wiki/How-To:-Allow-users-to-sign-in-using-their-username-or-email-address#tell-devise-to-use-username-in-the-authentication_keys
+          #
+          # Note: setting this option does modify the header_names behaviour,
+          # see the header_names section above.
+          #
+          # Example:
+          #
+          #   `config.identifiers = { super_admin: 'phone_number', user: 'uuid' }`
+          #
+          # config.identifiers = { user: 'email' }
+
+          # Configure the Devise trackable strategy integration.
+          #
+          # If true, tracking is disabled for token authentication: signing in through
+          # token authentication won't modify the Devise trackable statistics.
+          #
+          # If false, given Devise trackable is configured for the relevant model,
+          # then signing in through token authentication will be tracked as any other sign in.
+          #
+          # config.skip_devise_trackable = true
+        end
+      INITIALIZER
+    end
+
+    it { expect(generators_helper.simple_token_auth_initializer_tpl).to eq(expected) }
+  end
+end

data/spec/dummy/spec/lib/power_api/generator_helper/swagger_helper_spec.rb

@@ -0,0 +1,451 @@
+RSpec.describe PowerApi::GeneratorHelper::SwaggerHelper, type: :generator do
+  describe "#swagger_helper_path" do
+    let(:expected_path) { "spec/swagger_helper.rb" }
+
+    def perform
+      generators_helper.swagger_helper_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#spec_swagger_path" do
+    let(:expected_path) { "spec/swagger/.gitkeep" }
+
+    def perform
+      generators_helper.spec_swagger_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#spec_integration_path" do
+    let(:expected_path) { "spec/integration/.gitkeep" }
+
+    def perform
+      generators_helper.spec_integration_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#rswag_ui_initializer_path" do
+    let(:expected_path) { "config/initializers/rswag-ui.rb" }
+
+    def perform
+      generators_helper.rswag_ui_initializer_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#swagger_resource_schema_path" do
+    let(:expected_path) { "spec/swagger/v1/schemas/blog_schema.rb" }
+
+    def perform
+      generators_helper.swagger_resource_schema_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#swagger_version_definition_path" do
+    let(:expected_path) { "spec/swagger/v1/definition.rb" }
+
+    def perform
+      generators_helper.swagger_version_definition_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#swagger_resource_spec_path" do
+    let(:expected_path) { "spec/integration/api/v1/blogs_spec.rb" }
+
+    def perform
+      generators_helper.swagger_resource_spec_path
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#rswag_ui_configure_line" do
+    let(:expected_path) do
+      "Rswag::Ui.configure do |c|\n"
+    end
+
+    def perform
+      generators_helper.rswag_ui_configure_line
+    end
+
+    it { expect(perform).to eq(expected_path) }
+  end
+
+  describe "#swagger_helper_api_definition_line" do
+    let(:expected_line) do
+      "config.swagger_docs = {\n"
+    end
+
+    def perform
+      generators_helper.swagger_helper_api_definition_line
+    end
+
+    it { expect(perform).to eq(expected_line) }
+  end
+
+  describe "#swagger_definition_line_to_inject_schema" do
+    let(:expected_line) { /definitions: {/ }
+
+    def perform
+      generators_helper.swagger_definition_line_to_inject_schema
+    end
+
+    it { expect(perform).to eq(expected_line) }
+  end
+
+  describe "#swagger_helper_api_definition" do
+    let(:expected_tpl) do
+      <<-VERSION
+    'v1/swagger.json' => API_V1
+      VERSION
+    end
+
+    def perform
+      generators_helper.swagger_helper_api_definition
+    end
+
+    it { expect(perform).to eq(expected_tpl) }
+
+    context "with another version" do
+      let(:version_number) { "2" }
+
+      let(:expected_tpl) do
+        <<-VERSION
+    'v2/swagger.json' => API_V2,
+        VERSION
+      end
+
+      it { expect(perform).to eq(expected_tpl) }
+    end
+  end
+
+  describe "#rswag_ui_initializer_tpl" do
+    let(:expected_tpl) do
+      <<~INITIALIZER
+        Rswag::Ui.configure do |c|
+        end
+      INITIALIZER
+    end
+
+    def perform
+      generators_helper.rswag_ui_initializer_tpl
+    end
+
+    it { expect(perform).to eq(expected_tpl) }
+  end
+
+  describe "#swagger_definition_tpl" do
+    let(:expected_tpl) do
+      <<~DEFINITION
+        API_V1 = {
+          swagger: '2.0',
+          info: {
+            title: 'API V1',
+            version: 'v1'
+          },
+          basePath: '/api/v1',
+          definitions: {
+          }
+        }
+      DEFINITION
+    end
+
+    def perform
+      generators_helper.swagger_definition_tpl
+    end
+
+    it { expect(perform).to eq(expected_tpl) }
+  end
+
+  describe "swagger_helper_tpl" do
+    let(:template) do
+      <<~SWAGGER
+        require 'rails_helper'
+
+        Dir[::Rails.root.join("spec/swagger/**/schemas/*.rb")].each { |f| require f }
+        Dir[::Rails.root.join("spec/swagger/**/definition.rb")].each { |f| require f }
+
+        RSpec.configure do |config|
+          # Specify a root folder where Swagger JSON files are generated
+          # NOTE: If you're using the rswag-api to serve API descriptions, you'll need
+          # to ensure that it's confiugred to serve Swagger from the same folder
+          config.swagger_root = Rails.root.to_s + '/swagger'
+
+          # Define one or more Swagger documents and provide global metadata for each one
+          # When you run the 'rswag:specs:to_swagger' rake task, the complete Swagger will
+          # be generated at the provided relative path under swagger_root
+          # By default, the operations defined in spec files are added to the first
+          # document below. You can override this behavior by adding a swagger_doc tag to the
+          # the root example_group in your specs, e.g. describe '...', swagger_doc: 'v2/swagger.json'
+          config.swagger_docs = {
+          }
+        end
+      SWAGGER
+    end
+
+    def perform
+      generators_helper.swagger_helper_tpl
+    end
+
+    it { expect(perform).to eq(template) }
+  end
+
+  describe "#swagger_schema_tpl" do
+    let(:template) do
+      <<~SCHEMA
+        BLOG_SCHEMA = {
+          type: :object,
+          properties: {
+            id: { type: :string, example: '1' },
+            type: { type: :string, example: 'blog' },
+            attributes: {
+              type: :object,
+              properties: {
+        title: { type: :string, example: 'Some title' },
+        body: { type: :string, example: 'Some body' },
+        created_at: { type: :string, example: '1984-06-04 09:00', 'x-nullable': true },
+        updated_at: { type: :string, example: '1984-06-04 09:00', 'x-nullable': true },
+        portfolio_id: { type: :integer, example: 666, 'x-nullable': true }
+              },
+              required: [
+        :title,
+        :body
+              ]
+            }
+          },
+          required: [
+            :id,
+            :type,
+            :attributes
+          ]
+        }
+
+        BLOGS_COLLECTION_SCHEMA = {
+          type: "object",
+          properties: {
+            data: {
+              type: "array",
+              items: { "$ref" => "#/definitions/blog" }
+            }
+          },
+          required: [
+            :data
+          ]
+        }
+
+        BLOG_RESOURCE_SCHEMA = {
+          type: "object",
+          properties: {
+            data: { "$ref" => "#/definitions/blog" }
+          },
+          required: [
+            :data
+          ]
+        }
+      SCHEMA
+    end
+
+    def perform
+      generators_helper.swagger_schema_tpl
+    end
+
+    it { expect(perform).to eq(template) }
+  end
+
+  describe "#swagger_resource_spec_tpl" do
+    let(:template) do
+      <<~SPEC
+        require 'swagger_helper'
+
+        describe 'API V1 Blogs', swagger_doc: 'v1/swagger.json' do
+        path '/blogs' do
+        get 'Retrieves Blogs' do
+        description 'Retrieves all the blogs'
+        produces 'application/json'
+
+        let(:collection_count) { 5 }
+        let(:expected_collection_count) { collection_count }
+
+        before { create_list(:blog, collection_count) }
+        response '200', 'Blogs retrieved' do
+        schema('$ref' => '#/definitions/blogs_collection')
+
+        run_test! do |response|
+        expect(JSON.parse(response.body)['data'].count).to eq(expected_collection_count)
+        end
+        end
+
+        end
+
+        post 'Creates Blog' do
+        description 'Creates Blog'
+        consumes 'application/json'
+        produces 'application/json'
+        parameter(name: :blog, in: :body)
+
+        response '201', 'blog created' do
+        let(:blog) do
+        {
+        title: 'Some title',
+        body: 'Some body'}
+        end
+
+        run_test!
+        end
+
+        response '400', 'invalid attributes' do
+        let(:blog) do
+        {
+        title: nil}
+        end
+
+        run_test!
+        end
+
+        end
+
+        end
+
+        path '/blogs/{id}' do
+        parameter name: :id, in: :path, type: :integer
+
+        let(:existent_blog) { create(:blog) }
+        let(:id) { existent_blog.id }
+
+        get 'Retrieves Blog' do
+        produces 'application/json'
+
+        response '200', 'blog retrieved' do
+        schema('$ref' => '#/definitions/blog_resource')
+
+        run_test!
+        end
+
+        response '404', 'invalid blog id' do
+        let(:id) { 'invalid' }
+        run_test!
+        end
+
+        end
+
+        put 'Updates Blog' do
+        description 'Updates Blog'
+        consumes 'application/json'
+        produces 'application/json'
+        parameter(name: :blog, in: :body)
+
+        response '200', 'blog updated' do
+        let(:blog) do
+        {
+        title: 'Some title',
+        body: 'Some body'}
+        end
+
+        run_test!
+        end
+
+        response '400', 'invalid attributes' do
+        let(:blog) do
+        {
+        title: nil}
+        end
+
+        run_test!
+        end
+
+        end
+
+        delete 'Deletes Blog' do
+        produces 'application/json'
+        description 'Deletes specific blog'
+
+        response '204', 'blog deleted' do
+        run_test!
+        end
+
+        response '404', 'blog not found' do
+        let(:id) { 'invalid' }
+
+        run_test!
+        end
+
+        end
+
+        end
+
+        end
+      SPEC
+    end
+
+    def perform
+      generators_helper.swagger_resource_spec_tpl
+    end
+
+    it { expect(perform).to eq(template) }
+
+    context "with authenticated_resource option" do
+      let(:authenticated_resource) { "user" }
+
+      it { expect(perform).to include("let(:user) { create(:user) }") }
+      it { expect(perform).to include("let(:user_email) { user.email }") }
+      it { expect(perform).to include("let(:user_token) { user.authentication_token }") }
+      it { expect(perform).to include("parameter name: :user_email, in: :query, type: :string") }
+      it { expect(perform).to include("parameter name: :user_token, in: :query, type: :string") }
+      it { expect(perform).to include("response '401', 'user unauthorized' do") }
+    end
+
+    context "with owned_by_authenticated_resource option" do
+      let(:authenticated_resource) { "user" }
+      let(:owned_by_authenticated_resource) { true }
+
+      it { expect(perform).to include("create_list(:blog, collection_count, user: user)") }
+      it { expect(perform).to include("(:existent_blog) { create(:blog, user: user) }") }
+    end
+
+    context "with parent_resource option" do
+      let(:parent_resource_name) { "portfolio" }
+
+      it { expect(perform).to include("/portfolios/{portfolio_id}/blogs") }
+      it { expect(perform).to include("parameter name: :portfolio_id, in: :path, type: :integer") }
+      it { expect(perform).to include("reate_list(:blog, collection_count, portfolio: portfolio)") }
+      it { expect(perform).to include("let(:portfolio) { create(:portfolio) }") }
+      it { expect(perform).to include("(:existent_blog) { create(:blog, portfolio: portfolio) }") }
+    end
+  end
+
+  describe "#rswag_ui_swagger_endpoint" do
+    let(:expected_entry) do
+      "  c.swagger_endpoint '/api-docs/v1/swagger.json', 'API V1 Docs'\n"
+    end
+
+    def perform
+      generators_helper.rswag_ui_swagger_endpoint
+    end
+
+    it { expect(perform).to eq(expected_entry) }
+  end
+
+  describe "#swagger_definition_entry" do
+    let(:expected_entry) do
+      "\n    blog: BLOG_SCHEMA,\
+\n    blogs_collection: BLOGS_COLLECTION_SCHEMA,\
+\n    blog_resource: BLOG_RESOURCE_SCHEMA,"
+    end
+
+    def perform
+      generators_helper.swagger_definition_entry
+    end
+
+    it { expect(perform).to eq(expected_entry) }
+  end
+end