dirty_seed 0.1.7 → 0.1.8

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe DirtySeed::Assigners::DirtyAssigner do
-  let(:dirty_attribute) { build_dirty_attribute(type: :integer) }
-
-  describe '#initialize' do
-    it 'instantiates an instance' do
-      expect(described_class.new(dirty_attribute)).to be_a described_class
-    end
-  end
-
-  describe 'absent' do
-    context 'when value should be absent' do
-      it 'returns nil' do
-        bravos = DirtySeed::DataModel.bravo.seed(10)
-        expect(bravos.map(&:an_absent_value).all?(&:nil?)).to be true
-      end
-    end
-  end
-
-  describe 'inclusion' do
-    context 'when value should be one of options' do
-      let(:bravos) { DirtySeed::DataModel.bravo.seed(10) }
-
-      it 'returns a value from options [strings]' do
-        expect(
-          bravos.map(&:a_string_from_options).all? { |v| v.in? %w[foo bar zed] }
-        ).to be true
-      end
-
-      it 'returns a value from options [integers]' do
-        expect(
-          bravos.map(&:an_integer_from_options).all? { |v| v.in? [15, 30, 45] }
-        ).to be true
-      end
-    end
-  end
-
-  describe 'uniqueness' do
-    context 'when value should be unique' do
-      it 'returns unique values or nil' do
-        bravos = DirtySeed::DataModel.bravo.seed(20)
-        expect(bravos.map(&:a_unique_value).count(&:nil?)).to eq 10
-        expect(bravos.map(&:a_unique_value).compact).to eq bravos.map(&:a_unique_value).compact.uniq
-      end
-    end
-  end
-
-  describe '#unique?', skip: 'has been set private' do
-    let(:assigner) { described_class.new(dirty_attribute) }
-
-    context 'when there is a uniqueness validation' do
-      it 'returns true' do
-        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, uniqueness: true)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        expect(assigner.unique?).to be true
-      end
-    end
-
-    context 'when there is no uniqueness validation' do
-      it 'returns false' do
-        expect(assigner.unique?).to be false
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe DirtySeed::Assigners::DirtyFloat do
-  let(:dirty_attribute) { build_dirty_attribute(type: :float) }
-
-  describe '#define_value' do
-    context 'when there are no validators' do
-      it 'returns an integer' do
-        expect(described_class.new(dirty_attribute).define_value).to be_a Float
-      end
-    end
-
-    context 'when there is greater_than validator' do
-      it 'returns an integer greater than the requirement' do
-        assigner = described_class.new(dirty_attribute)
-        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1_000)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        5.times { expect(assigner.define_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(dirty_attribute)
-        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: -1_000)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        5.times { expect(assigner.define_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
-        greater_than = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 0)
-        less_than = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: 1)
-        assigner = described_class.new(dirty_attribute)
-        allow(assigner.dirty_attribute).to(receive(:validators).and_return([greater_than, less_than]))
-        5.times { expect(assigner.define_value).to be_between(0, 1).exclusive }
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe DirtySeed::Assigners::DirtyInteger do
-  let(:dirty_attribute) { build_dirty_attribute(type: :integer) }
-
-  describe '#define_value' do
-    context 'when there are no validators' do
-      it 'returns an integer' do
-        expect(described_class.new(dirty_attribute).define_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(dirty_attribute)
-        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1_000)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        5.times { expect(assigner.define_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(dirty_attribute)
-        validator = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: -1_000)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        5.times { expect(assigner.define_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
-        greater_than = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, greater_than: 1)
-        less_than = ActiveModel::Validations::NumericalityValidator.new(attributes: :fake, less_than: 5)
-        assigner = described_class.new(dirty_attribute)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([greater_than, less_than])
-        5.times { expect(assigner.define_value).to be_between(1, 5).exclusive }
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe DirtySeed::Assigners::DirtyString do
-  let(:data_model) { DirtySeed::DataModel }
-  let(:dirty_attribute) { build_dirty_attribute(type: :string) }
-
-  describe '#define_value' do
-    context 'when there are no validators' do
-      it 'returns a String' do
-        expect(described_class.new(dirty_attribute).define_value).to be_a String
-      end
-    end
-
-    context 'when value should match pattern' do
-      it 'returns a value matching the pattern' do
-        dirty_attribute = build_dirty_attribute(type: :string)
-        assigner = described_class.new(dirty_attribute)
-        regex = /\w{10}@(hotmail|gmail)\.com/
-        validator = ActiveModel::Validations::FormatValidator.new(attributes: :fake, with: regex)
-        allow(assigner.dirty_attribute).to receive(:validators).and_return([validator])
-        expect(assigner.value).to match(regex)
-      end
-    end
-
-    context 'when meaning can be guessed' do
-      it 'returns a meaningfull String [email]' do
-        email_attribute = build_dirty_attribute(name: :email, type: :string)
-        assigner = described_class.new(email_attribute)
-        expect(assigner.value).to match(URI::MailTo::EMAIL_REGEXP)
-      end
-
-      it 'returns a meaningfull String [latitude]' do
-        latitude_attribute = build_dirty_attribute(name: :latitude, type: :string)
-        assigner = described_class.new(latitude_attribute)
-        expect(assigner.value.to_s).to match(/-?\d+\.\d+/)
-      end
-
-      it 'returns a meaningfull String [locale]' do
-        locale_attribute = build_dirty_attribute(name: :locale, type: :string)
-        assigner = described_class.new(locale_attribute)
-        expect(assigner.value).to match(/[A-Z]{2}/)
-      end
-
-      it 'returns a meaningfull String [uuid]' do
-        uuid_attribute = build_dirty_attribute(name: :uuid, type: :string)
-        assigner = described_class.new(uuid_attribute)
-        expect(assigner.value).to match(/([a-z]|-|\d){36}/)
-      end
-    end
-  end
-end

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

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

data/spec/lib/dirty_seed/dirty_association_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe DirtySeed::DirtyAssociation do
-  let(:dirty_model)       { DirtySeed::DataModel.charlie }
-  let(:reflection)        { Charlie.reflections['alfa'] }
-  let(:dirty_association) { described_class.new(dirty_model, reflection) }
-
-  describe '#initialize' do
-    it 'instantiates an instance' do
-      expect(dirty_association).to be_a described_class
-    end
-  end
-
-  describe '#dirty_model' do
-    it 'returns dirty model' do
-      expect(dirty_association.dirty_model).to eq dirty_model
-    end
-  end
-
-  describe '#name' do
-    it 'returns attribute name' do
-      expect(dirty_association.name).to eq :alfa
-    end
-  end
-
-  describe '#attribute' do
-    it 'returns attribute of this association' do
-      expect(dirty_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(dirty_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
-        dirty_model = DirtySeed::DataModel.echo
-        reflection = Echo.reflections['echoable']
-        dirty_association = described_class.new(dirty_model, reflection)
-        expect(dirty_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
-        dirty_model = DirtySeed::DataModel.hotel
-        reflection = Hotel.reflections['india']
-        dirty_association = described_class.new(dirty_model, reflection)
-        expect(dirty_association.associated_models).to eq [India]
-
-        dirty_model = DirtySeed::DataModel.india
-        reflection = India.reflections['hotel']
-        dirty_association = described_class.new(dirty_model, reflection)
-        expect(dirty_association.associated_models).to eq [Hotel]
-      end
-    end
-  end
-end

data/spec/lib/dirty_seed/dirty_attribute_spec.rb

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