dirty_seed 0.1.7 → 0.1.8

data/spec/lib/dirty_seed/assigners/assigner_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Assigner do
+  describe 'uniqueness' do
+    context 'when value should be unique' do
+      it 'returns unique value or nil' do
+        attribute = build_attribute(type: :integer)
+        assigner = DirtySeed::Assigners::Integer.new(attribute)
+        range = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, in: 1..2)
+        uniqueness = ActiveRecord::Validations::UniquenessValidator.new(attributes: :fake)
+        allow(assigner.attribute).to receive(:validators).and_return([range, uniqueness])
+        values = 4.times.map { assigner.value }
+        expect(values).to match_array([1, 2, nil, nil])
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/base_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Base do
+  let(:attribute) { build_attribute(type: :integer) }
+  let(:assigner) { described_class.new(attribute) }
+
+  describe '#initialize' do
+    it 'instantiates an instance' do
+      expect(described_class.new(attribute)).to be_a described_class
+    end
+  end
+
+  describe '#value' do
+    context 'when value should be absent (absence: true)' do
+      it 'returns nil' do
+        validator = ActiveRecord::Validations::AbsenceValidator.new(attributes: :fake)
+        allow(assigner.attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be_nil }
+      end
+    end
+
+    context 'when value should be one of given options (inclusion: { in: %w[foo bar zed] })' do
+      context 'when type is a string' do
+        it 'returns one of the options' do
+          attribute = build_attribute(type: :string)
+          validator = ActiveModel::Validations::InclusionValidator.new(attributes: :fake, in: %w[foo bar zed])
+          allow(attribute).to receive(:validators).and_return([validator])
+          assigner = described_class.new(attribute)
+          10.times { expect(assigner.value).to be_in(%w[foo bar zed]) }
+        end
+      end
+
+      context 'when type is an integer' do
+        it 'returns one of the options' do
+          attribute = build_attribute(type: :integer)
+          validator = ActiveModel::Validations::InclusionValidator.new(attributes: :fake, in: [15, 30, 45])
+          allow(attribute).to receive(:validators).and_return([validator])
+          assigner = described_class.new(attribute)
+          10.times { expect(assigner.value).to be_in([15, 30, 45]) }
+        end
+      end
+
+      context 'when inclusion is a range (in: 0.0..1.0)' do
+        it 'returns a value included in the range' do
+          assigner = described_class.new(attribute)
+          validator = ActiveModel::Validations::InclusionValidator.new(attributes: :fake, in: 0.0..1.0)
+          allow(attribute).to receive(:validators).and_return([validator])
+          10.times { expect(assigner.value).to be_between(0, 1) }
+        end
+      end
+    end
+
+    context 'when attribute name is listed in meaningful attributes' do
+      context 'when attribute type matches accepted types' do
+        it 'returns a meaningful value (example: string "email")' do
+          attribute = build_attribute(name: :email, type: :string)
+          assigner = described_class.new(attribute)
+          10.times { expect(assigner.value).to match(URI::MailTo::EMAIL_REGEXP) }
+        end
+
+        it 'returns a meaningful value (example: float "latitude")' do
+          attribute = build_attribute(name: :latitude, type: :float)
+          assigner = described_class.new(attribute)
+          expect(assigner.value).to be_a Float
+          10.times { expect(assigner.value.to_s).to match(/-?\d+\.\d{9,}/) }
+        end
+      end
+
+      context 'when attribute type does not match accepted types' do
+        it 'returns a value that is not meaningful' do
+          attribute = build_attribute(name: :latitude, type: :string)
+          assigner = described_class.new(attribute)
+          expect(assigner.value).to be_a String
+          10.times { expect(assigner.value).not_to match(/-?\d+\.\d{9,}/) }
+        end
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/boolean_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Boolean do
+  let(:attribute) { build_attribute(type: :boolean) }
+
+  describe '#value' do
+    it 'returns a Boolean' do
+      10.times { expect(described_class.new(attribute).value).to be_in([true, false]) }
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/date_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Date do
+  let(:attribute) { build_attribute(type: :date) }
+
+  describe '#value' do
+    context 'when there are no validators' do
+      it 'returns a Date' do
+        10.times { expect(described_class.new(attribute).value).to be_a Date }
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/float_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Float do
+  let(:attribute) { build_attribute(type: :float) }
+
+  describe '#value' do
+    context 'when there are no validators' do
+      it 'returns a float' do
+        10.times { expect(described_class.new(attribute).value).to be_a Float }
+      end
+    end
+
+    context 'when there is greater_than validator' do
+      it 'returns a float greater than the requirement' do
+        assigner = described_class.new(attribute)
+        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1_000)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be >= 1_000 }
+      end
+    end
+
+    context 'when there is less_than validator' do
+      it 'returns a float less than the requirement' do
+        assigner = described_class.new(attribute)
+        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: -1_000)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be < -1_000 }
+      end
+    end
+
+    context 'when there is greater_and less_than validators' do
+      it 'returns a float greater than and less than the requirements' do
+        assigner = described_class.new(attribute)
+        validator =
+          ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 0, less_than: 1)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be_between(0, 1).exclusive }
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/integer_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Integer do
+  let(:attribute) { build_attribute(type: :integer) }
+
+  describe '#value' do
+    context 'when there are no validators' do
+      it 'returns an integer' do
+        10.times { expect(described_class.new(attribute).value).to be_an Integer }
+      end
+    end
+
+    context 'when there is greater_than validator' do
+      it 'returns an integer greater than the requirement' do
+        assigner = described_class.new(attribute)
+        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1_000)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be >= 1_000 }
+      end
+    end
+
+    context 'when there is less_than validator' do
+      it 'returns an integer less than the requirement' do
+        assigner = described_class.new(attribute)
+        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: -1_000)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be < -1_000 }
+      end
+    end
+
+    context 'when there are less_than and greater_than validators' do
+      it 'returns an integer greater than and less than the requirements' do
+        assigner = described_class.new(attribute)
+        validator =
+          ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1, less_than: 5)
+        allow(attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to be_between(1, 5).exclusive }
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/string_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::String do
+  let(:data_model) { DirtySeed::DataModel }
+  let(:attribute) { build_attribute(type: :string) }
+
+  describe '#value' do
+    context 'when there are no validators' do
+      it 'returns a String' do
+        expect(described_class.new(attribute).value).to be_a String
+      end
+    end
+
+    context 'when value should match pattern' do
+      it 'returns a value matching the pattern' do
+        attribute = build_attribute(type: :string)
+        assigner = described_class.new(attribute)
+        regex = /\w{10}@(hotmail|gmail)\.com/
+        validator = ActiveModel::Validations::FormatValidator.new(attributes: :fake, with: regex)
+        allow(assigner.attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value).to match(regex) }
+      end
+    end
+
+    context 'when the length has a minimim validation' do
+      it 'returns a value with the required length' do
+        attribute = build_attribute(type: :string)
+        assigner = described_class.new(attribute)
+        validator = ActiveRecord::Validations::LengthValidator.new(attributes: :fake, minimum: 5)
+        allow(assigner.attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value.length).to be >= 5 }
+      end
+    end
+
+    context 'when the length has a maximum validation' do
+      it 'returns a value with the required length' do
+        attribute = build_attribute(type: :string)
+        assigner = described_class.new(attribute)
+        validator = ActiveRecord::Validations::LengthValidator.new(attributes: :fake, maximum: 5)
+        allow(assigner.attribute).to receive(:validators).and_return([validator])
+        10.times { expect(assigner.value.length).to be <= 5 }
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/assigners/time_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Assigners::Time do
+  let(:attribute) { build_attribute(type: :time) }
+
+  describe '#value' do
+    context 'when there are no validators' do
+      it 'returns a Time' do
+        10.times { expect(described_class.new(attribute).value).to be_a Time }
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/association_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Association do
+  let(:model) { DirtySeed::DataModel.charlie }
+  let(:reflection) { Charlie.reflections['alfa'] }
+  let(:association) { described_class.new(model, reflection) }
+
+  describe '#initialize' do
+    it 'instantiates an instance' do
+      expect(association).to be_a described_class
+    end
+  end
+
+  describe '#model' do
+    it 'returns dirty model' do
+      expect(association.model).to eq model
+    end
+  end
+
+  describe '#name' do
+    it 'returns attribute name' do
+      expect(association.name).to eq :alfa
+    end
+  end
+
+  describe '#attribute' do
+    it 'returns attribute of this association' do
+      expect(association.attribute).to eq :alfa_id
+    end
+  end
+
+  describe '#associated_models' do
+    context 'when the reflection is regular' do
+      it 'returns belongs_to association' do
+        expect(association.associated_models).to eq [Alfa]
+      end
+    end
+
+    context 'when the reflection is polymorphic' do
+      it 'returns models associated with has_many or has_one' do
+        model = DirtySeed::DataModel.echo
+        reflection = Echo.reflections['echoable']
+        association = described_class.new(model, reflection)
+        expect(association.associated_models).to eq [Alfa, Charlie]
+      end
+    end
+
+    context 'when the reflection is cyclic (a belongs to b and b optionnally belongs to a)' do
+      it 'returns models accepting this one as polymorphic' do
+        model = DirtySeed::DataModel.hotel
+        reflection = Hotel.reflections['india']
+        association = described_class.new(model, reflection)
+        expect(association.associated_models).to eq [India]
+
+        model = DirtySeed::DataModel.india
+        reflection = India.reflections['hotel']
+        association = described_class.new(model, reflection)
+        expect(association.associated_models).to eq [Hotel]
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/attribute_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe DirtySeed::Attribute do
+  let(:attribute) { described_class.new(build_model, build_column) }
+
+  describe '#initialize' do
+    it 'instantiates an instance' do
+      expect(attribute).to be_a described_class
+    end
+  end
+
+  describe '#model' do
+    it 'returns dirty model' do
+      expect(attribute.model).to be_a DirtySeed::Model
+    end
+  end
+
+  describe '#type' do
+    context 'when column is a boolean' do
+      it 'returns :boolean' do
+        attribute = described_class.new(build_model, build_column(type: :boolean))
+        expect(attribute.type).to eq :boolean
+      end
+    end
+
+    context 'when column is an integer' do
+      it 'returns :integer' do
+        attribute = described_class.new(build_model, build_column(type: :integer))
+        expect(attribute.type).to eq :integer
+      end
+    end
+
+    context 'when column is a decimal' do
+      it 'returns :float' do
+        attribute = described_class.new(build_model, build_column(type: :float))
+        expect(attribute.type).to eq :float
+      end
+    end
+
+    context 'when column is a string' do
+      it 'returns :string' do
+        attribute = described_class.new(build_model, build_column(type: :string))
+        expect(attribute.type).to eq :string
+      end
+    end
+  end
+end

data/spec/lib/dirty_seed/data_model_spec.rb

@@ -6,41 +6,13 @@ RSpec.describe DirtySeed::DataModel do
   describe '::seed' do
     context 'when ApplicationRecord is defined' do
       it 'seeds instances for each model' do
-        described_class.reset
-        described_class.seed(1)
-        # As expected, Juliett can not be seed
-        [Alfa, Bravo, Charlie, Delta, Echo, Foxtrot, Golf, Hotel, India].each do |active_record_model|
-          expect(active_record_model.count).to be > 0
-        end
+        expect { described_class.seed(3) }.to change(Alfa, :count).by(3).and change(Golf, :count).by(3)
       end
 
-      it 'logs data' do # rubocop:disable RSpec/ExampleLength
-        described_class.reset
-        expect { described_class.seed(8) }.to output(
-          <<~LOG
-            Alfa
-              created: 8
-            Bravo
-              created: 8
-            Charlie
-              created: 8
-            Delta
-              created: 8
-            Echo
-              created: 8
-            Foxtrot
-              created: 8
-            Golf
-              created: 8
-            Hotel
-              created: 8
-            India
-              created: 8
-            Juliett
-              created: 0
-              errors: Alfa should be some specific alfa, A string should be a specific string, An integer should be a specific integer
-          LOG
-        ).to_stdout
+      it 'logs data' do
+        expect { described_class.seed(1) }.to output(/Alfa/).to_stdout
+        expect { described_class.seed(2) }.to output(/seeded: 2/).to_stdout
+        expect { described_class.seed(1) }.to output(/(errors:)(.*)(A string should be a specific string)/).to_stdout
       end
     end
 
@@ -52,9 +24,9 @@ RSpec.describe DirtySeed::DataModel do
     end
   end
 
-  describe '::dirty_models' do
+  describe '::models' do
     it 'returns an array of dirty models representing Active Record models' do
-      expect(described_class.dirty_models.map(&:name)).to match_array(
+      expect(described_class.models.map(&:name)).to match_array(
         %w[Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliett]
       )
     end
@@ -79,7 +51,7 @@ RSpec.describe DirtySeed::DataModel do
   describe '#method_missing' do
     context 'when method_name matches an ActiveRecord model' do
       it 'returns the related dirty model' do
-        dirty_alfa = described_class.dirty_models.find { |dirty_model| dirty_model.model == Alfa }
+        dirty_alfa = described_class.models.find { |model| model.model == Alfa }
         expect(described_class.respond_to_missing?(:alfa)).to be true
         expect(described_class.alfa).to eq dirty_alfa
       end