Refactor specs to replace inline parameter class definitions with FactoryBot factories

Author: Syati

spec/factories/user_parameters.rb

@@ -19,8 +19,8 @@ class UserParameter < StructuredParams::Params
     email { 'tanaka@example.com' }
     age { 30 }
     address { attributes_for(:address_parameter) }
-    hobbies { attributes_for_list(:hobby_parameter, 3) }
-    tags { [] }
+    hobbies { attributes_for_list(:hobby_parameter, 2) }
+    tags { %w[Ruby Rails Web] }
 
     initialize_with { new(attributes) }
   end

spec/params_spec.rb

@@ -3,64 +3,10 @@
 require 'spec_helper'
 
 RSpec.describe StructuredParams::Params do
-  # Test parameter class definitions
-  let(:address_parameter_class) do
-    Class.new(described_class) do
-      def self.name
-        'AddressParameter'
-      end
-
-      attribute :postal_code, :string
-      attribute :prefecture, :string
-      attribute :city, :string
-      attribute :street, :string
-
-      validates :postal_code, presence: true, format: { with: /\A\d{3}-\d{4}\z/ }
-      validates :prefecture, presence: true
-      validates :city, presence: true
-    end
-  end
-
-  let(:hobby_parameter_class) do
-    Class.new(described_class) do
-      def self.name
-        'HobbyParameter'
-      end
-
-      attribute :name, :string
-      attribute :level, :integer
-      attribute :years_experience, :integer
-
-      validates :name, presence: true
-      validates :level, inclusion: { in: 1..3 }
-      validates :years_experience, numericality: { greater_than_or_equal_to: 0 }
-    end
-  end
-
-  let(:user_parameter_class) do
-    address_class = address_parameter_class
-    hobby_class = hobby_parameter_class
-
-    Class.new(described_class) do
-      def self.name
-        'UserParameter'
-      end
-
-      attribute :name, :string
-      attribute :email, :string
-      attribute :age, :integer
-      attribute :address, :object, value_class: address_class
-      attribute :hobbies, :array, value_class: hobby_class
-      attribute :tags, :array, value_type: :string
-
-      validates :name, presence: true, length: { maximum: 50 }
-      validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
-      validates :age, numericality: { greater_than: 0 }
-    end
-  end
-
   describe '.permit_attribute_names' do
-    subject(:permit_attribute_names) { user_parameter_class.permit_attribute_names }
+    subject(:permit_attribute_names) do
+      UserParameter.permit_attribute_names
+    end
 
     it {
       expect(permit_attribute_names).to eq([:name, :email, :age,
@@ -84,14 +30,14 @@ def self.name
         },
         hobbies: [
           { name: 'programming', level: 3, years_experience: 10 },
-          { name: '読書', level: 2, years_experience: 5 }
+          { name: 'Web', level: 2, years_experience: 5 }
         ],
-        tags: %w[Ruby Rails 技術書]
+        tags: %w[Ruby Rails Web]
       }
     end
 
     context 'with valid parameters' do
-      subject(:user_param) { user_parameter_class.new(valid_params) }
+      subject(:user_param) { build(:user_parameter, **valid_params) }
 
       it {
         expect(user_param).to have_attributes(
@@ -104,7 +50,7 @@ def self.name
       context 'with object parameters' do
         subject(:address) { user_param.address }
 
-        it { is_expected.to be_instance_of(address_parameter_class) }
+        it { is_expected.to be_instance_of(AddressParameter) }
 
         it {
           expect(address).to have_attributes(
@@ -120,20 +66,20 @@ def self.name
         subject(:hobbies) { user_param.hobbies }
 
         it { is_expected.to be_an(Array) }
-        it { is_expected.to contain_exactly(hobby_parameter_class, hobby_parameter_class) }
+        it { is_expected.to contain_exactly(HobbyParameter, HobbyParameter) }
         it { expect(hobbies[0]).to have_attributes(name: 'programming', level: 3, years_experience: 10) }
-        it { expect(hobbies[1]).to have_attributes(name: '読書', level: 2, years_experience: 5) }
+        it { expect(hobbies[1]).to have_attributes(name: 'Web', level: 2, years_experience: 5) }
       end
 
       context 'with array of strings' do
         subject { user_param.tags }
 
-        it { is_expected.to eq(%w[Ruby Rails 技術書]) }
+        it { is_expected.to eq(%w[Ruby Rails Web]) }
       end
     end
 
     context 'with ActionController::Parameters' do
-      subject(:user_param) { user_parameter_class.new(action_controller_params) }
+      subject(:user_param) { UserParameter.new(action_controller_params) }
 
       let(:action_controller_params) do
         ActionController::Parameters.new(valid_params.merge(unpermitted: 'value'))
@@ -147,50 +93,24 @@ def self.name
 
     context 'with invalid parameter type' do
       it 'raises ArgumentError' do
-        expect { user_parameter_class.new('invalid') }.to raise_error(ArgumentError)
+        expect { UserParameter.new('invalid') }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe '#valid?' do
     context 'with valid object parameters' do
-      subject(:user_param) { user_parameter_class.new(valid_params) }
-
-      let(:valid_params) do
-        {
-          name: 'Tanaka Taro',
-          email: 'tanaka@example.com',
-          age: 30,
-          address: {
-            postal_code: '123-4567',
-            prefecture: 'Tokyo',
-            city: 'Shibuya-ku',
-            street: 'Saka 1-2-3'
-          },
-          hobbies: [
-            { name: 'programming', level: 3, years_experience: 10 }
-          ]
-        }
-      end
+      subject(:user_param) { build(:user_parameter) }
 
       it { is_expected.to be_valid }
     end
 
     context 'with invalid parent parameters' do
-      subject(:user_param) { user_parameter_class.new(invalid_parent_params) }
-
-      let(:invalid_parent_params) do
-        {
-          name: '', # invalid
-          email: 'invalid-email', # invalid
-          age: -1, # invalid
-          address: {
-            postal_code: '123-4567',
-            prefecture: 'Tokyo',
-            city: 'Shibuya-ku',
-            street: 'Saka 1-2-3'
-          }
-        }
+      subject(:user_param) do
+        build(:user_parameter,
+              name: '',
+              email: 'invalid-email',
+              age: -1)
       end
 
       it 'returns false and includes parent validation errors' do
@@ -202,20 +122,15 @@ def self.name
     end
 
     context 'with invalid object single object' do
-      subject(:user_param) { user_parameter_class.new(invalid_address_params) }
-
-      let(:invalid_address_params) do
-        {
-          name: '', # invalid
-          email: 'tanaka@example.com',
-          age: 30,
-          address: {
-            postal_code: 'invalid', # invalid format
-            prefecture: '', # blank
-            city: 'Shibuya-ku',
-            street: 'Saka 1-2-3'
-          }
-        }
+      subject(:user_param) do
+        build(:user_parameter,
+              name: '', # blank
+              address: {
+                postal_code: 'invalid', # invalid format
+                prefecture: '', # blank
+                city: 'Shibuya-ku',
+                street: 'Saka 1-2-3'
+              })
       end
 
       it 'returns false and includes object validation errors' do
@@ -227,94 +142,46 @@ def self.name
     end
 
     context 'with invalid object array objects' do
-      subject(:user_param) { user_parameter_class.new(invalid_hobbies_params) }
-
-      let(:invalid_hobbies_params) do
-        {
-          name: 'Tanaka Taro',
-          email: 'tanaka@example.com',
-          age: 30,
-          hobbies: [
-            { name: '', level: 5, years_experience: -1 }, # all invalid
-            { name: 'valid hobby', level: 2, years_experience: 3 } # valid
-          ]
-        }
+      subject(:user_param) do
+        build(:user_parameter,
+              hobbies: [
+                { name: '', level: 5, years_experience: -1 }, # all invalid
+                { name: 'valid hobby', level: 2, years_experience: 3 } # valid
+              ])
       end
 
       it 'returns false and includes array validation errors with index' do
         expect(user_param).not_to be_valid
-        expect(user_param.errors['hobbies.0.name']).to include("can't be blank")
-        expect(user_param.errors['hobbies.0.level']).to include('is not included in the list')
-        expect(user_param.errors['hobbies.0.years_experience']).to include('must be greater than or equal to 0')
+        expect(user_param.errors[:'hobbies.0.name']).to include("can't be blank")
+        expect(user_param.errors[:'hobbies.0.level']).to include('is not included in the list')
+        expect(user_param.errors[:'hobbies.0.years_experience']).to include('must be greater than or equal to 0')
       end
     end
   end
 
   describe '#attributes' do
-    subject(:attributes) { user_parameter_class.new(params).attributes(symbolize: symbolize) }
+    subject(:attributes) { build(:user_parameter, **user_param_attributes).attributes(symbolize: symbolize) }
 
-    let(:symbolize) { false }
+    let(:user_param_attributes) { attributes_for(:user_parameter) }
 
-    let(:params) do
-      {
-        name: 'Tanaka Taro',
-        email: 'tanaka@example.com',
-        age: 30,
-        address: {
-          postal_code: '123-4567',
-          prefecture: 'Tokyo',
-          city: 'Shibuya-ku',
-          street: 'Saka 1-2-3'
-        },
-        hobbies: [
-          { name: 'programming', level: 3, years_experience: 10 }
-        ],
-        tags: %w[Ruby Rails]
-      }
-    end
+    context 'when symbolize: false' do
+      let(:symbolize) { false }
 
-    it 'returns attributes with objects converted to hashes' do
-      expect(attributes).to include(
-        'name' => 'Tanaka Taro',
-        'address' => hash_including(
-          'postal_code' => '123-4567',
-          'prefecture' => 'Tokyo',
-          'city' => 'Shibuya-ku',
-          'street' => 'Saka 1-2-3'
-        ),
-        'hobbies' => array_including(
-          hash_including('name' => 'programming', 'level' => 3, 'years_experience' => 10)
-        ),
-        'tags' => %w[Ruby Rails]
-      )
+      it { is_expected.to eq user_param_attributes.deep_stringify_keys }
     end
 
     context 'with symbolize: true' do
       let(:symbolize) { true }
 
-      it 'returns symbolized attributes' do
-        expect(attributes).to include(
-          name: 'Tanaka Taro',
-          address: hash_including(
-            postal_code: '123-4567',
-            prefecture: 'Tokyo',
-            city: 'Shibuya-ku',
-            street: 'Saka 1-2-3'
-          ),
-          hobbies: array_including(
-            hash_including(name: 'programming', level: 3, years_experience: 10)
-          ),
-          tags: %w[Ruby Rails]
-        )
-      end
+      it { is_expected.to eq user_param_attributes.deep_symbolize_keys }
     end
   end
 
   describe 'edge cases' do
-    context 'with nil object values' do
-      subject(:user_param) { user_parameter_class.new(params_with_nil) }
+    subject(:user_param) { build(:user_parameter, **params) }
 
-      let(:params_with_nil) do
+    context 'with nil object values' do
+      let(:params) do
         {
           name: 'Tanaka Taro',
           email: 'tanaka@example.com',
@@ -335,9 +202,7 @@ def self.name
     end
 
     context 'with empty arrays' do
-      subject(:user_param) { user_parameter_class.new(params_with_empty_arrays) }
-
-      let(:params_with_empty_arrays) do
+      let(:params) do
         {
           name: 'Tanaka Taro',
           email: 'tanaka@example.com',