workarea-core 3.4.12

data/test/models/workarea/content/block_type_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    class BlockTypeTest < TestCase
+      def test_config
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          width 960
+          height 470
+        end
+
+        assert_equal({ width: 960, height: 470 }, block_type.config)
+      end
+
+      def test_defaults
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          field :foo, :string, default: 'foo'
+          field :bar, :string, default: 'bar'
+        end
+
+        assert_equal({ foo: 'foo', bar: 'bar' }, block_type.defaults)
+      end
+
+      def test_field
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          field :foo, :string, default: 'foo'
+        end
+
+        assert(block_type.fieldsets.first.instance_of?(Fieldset))
+        assert_equal('Settings', block_type.fieldsets.first.name)
+      end
+
+      def test_series
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          field :foo, :string, default: 'foo'
+
+          series 3 do
+            field :bar, :string, default: 'bar'
+            field :baz, :string, default: 'bar'
+          end
+        end
+
+        assert_equal(3, block_type.series.length)
+        assert(block_type.series.first.instance_of?(Fieldset))
+        assert('1st', block_type.series.first.name)
+      end
+
+      def test_fieldset
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          fieldset 'Foo Fields' do
+            field :foo, :string, default: 'foo'
+          end
+
+          fieldset 'Bar Fields', replaces: 'Foo Fields' do
+            field :bar, :string, default: 'foo'
+            field :baz, :string, default: 'bar'
+          end
+        end
+
+        assert_equal(1, block_type.fieldsets.count)
+        fieldset = block_type.fieldsets.first
+        field_names = fieldset.fields.map(&:name)
+        refute_includes(field_names, :foo)
+        assert_includes(field_names, :bar)
+        assert_includes(field_names, :baz)
+        assert_equal('Bar Fields', fieldset.name)
+      end
+
+      def test_remove_fieldset
+        block_type = BlockType.new('Foo')
+        block_type.instance_eval do
+          fieldset 'Foo Fields' do
+            field :foo, :string, default: 'foo'
+          end
+
+          fieldset 'Bar Fields' do
+            field :bar, :string
+          end
+
+          remove_fieldset 'Foo Fields'
+        end
+
+        fieldsets = block_type.fieldsets.map(&:name)
+
+        refute_includes(fieldsets, 'Foo Fields')
+        assert_includes(fieldsets, 'Bar Fields')
+      end
+    end
+  end
+end

data/test/models/workarea/content/email_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    class EmailTest < TestCase
+      def test_find_by_type
+        Email.create!(type: 'type1', content: 'foo')
+        Email.create!(type: 'type2', content: 'bar')
+
+        email = Email.find_by_type('type1')
+        assert_equal('foo', email.content)
+      end
+
+      def test_name
+        email = Email.create!(type: 'account_creation', content: 'foo')
+        assert_equal('Account Creation', email.name)
+      end
+    end
+  end
+end

data/test/models/workarea/content/field_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    class FieldTest < TestCase
+      def test_default
+        field = Field.new('foo', default: 'bar')
+        assert_equal('bar', field.default)
+
+        field = Field.new('foo', default: -> { rand(5) })
+        assert(field.default.is_a?(Integer))
+      end
+    end
+  end
+end

data/test/models/workarea/content/fields/asset_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    module Fields
+      class AssetTest < TestCase
+        def test_typecasting
+          asset = Asset.new('foo')
+          id = BSON::ObjectId.new
+
+          assert_equal(id.to_s, asset.typecast(id))
+          assert_equal(id.to_s, asset.typecast(id.to_s))
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/content/fields/products_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    module Fields
+      class ProductsTest < TestCase
+        def test_typecast
+          result = Products.new('foo').typecast([1, 2, 3])
+          assert_equal(%w(1 2 3), result)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/content/page_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+module Workarea
+  class Content
+    class PageTest < TestCase
+      include NavigableTest
+
+      def navigable_class
+        Page
+      end
+    end
+  end
+end

data/test/models/workarea/content_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Workarea
+  class ContentTest < Workarea::TestCase
+    class Foo
+      include Mongoid::Document
+      include Contentable
+
+      field :name, type: String
+    end
+
+    setup do
+      @content = create_content
+    end
+
+    def test_defaulting_to_the_contentable_name
+      model = Foo.new(name: 'Foo content')
+      assert_equal(Content.new(contentable: model).name, 'Foo content')
+    end
+
+    def test_finding_content_by_block_id
+      block = @content.blocks.create!(type: 'html')
+
+      assert_equal(@content, Content.from_block(block.id))
+      assert_equal(@content, Content.from_block(block.id.to_s))
+    end
+  end
+end

data/test/models/workarea/data_file/csv_test.rb

@@ -0,0 +1,408 @@
+require 'test_helper'
+
+module Workarea
+  module DataFile
+    class CsvTest < TestCase
+      class Foo
+        include ApplicationDocument
+        field :name, type: String
+        field :local, type: Boolean, localize: true
+        field :hash_test, type: Hash
+        field :payment, type: ActiveMerchant::Billing::Response
+        field :validated_field, type: String
+
+        embeds_many :bars
+        embeds_many :bazzets
+        embeds_one :baz
+
+        cattr_accessor :validation_failure
+        validate :validated_field_is_valid
+
+        def validated_field_is_valid
+          errors.add(:base, 'error!') if validation_failure
+        end
+      end
+
+      class Bar
+        include ApplicationDocument
+        field :name, type: String
+        field :array, type: Array
+        field :ignore, type: Integer
+        field :hash_test, type: Hash
+        embedded_in :foo
+      end
+
+      class Baz
+        include ApplicationDocument
+        field :name, type: String
+        field :hash_test, type: Hash
+        embedded_in :foo
+      end
+
+      class Bazzet
+        include ApplicationDocument
+        extend Dragonfly::Model
+        field :image_uid, type: String
+        dragonfly_accessor :image, app: :workarea
+        embedded_in :foo
+      end
+
+      def test_merging_rows_for_embedded
+        model = Foo.create!(
+          bars: [{ name: '1' }, { name: '2' }],
+          baz: { name: '3' }
+        )
+
+        csv = Csv.new.serialize(model)
+        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+
+        assert_equal(2, results.size)
+        results.each { |r| assert_equal(model.id.to_s, r['_id']) }
+        assert_equal('1', results.first['bars_name'])
+        assert_equal('2', results.second['bars_name'])
+        assert_equal('3', results.first['baz_name'])
+      end
+
+      def test_handles_blank_embedded
+        model = Foo.create!(name: '1')
+        csv = Csv.new.serialize(model)
+        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+
+        assert_equal(1, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        assert_equal('1', results.first['name'])
+      end
+
+      def test_handles_localized_fields
+        set_locales(available: [:en, :es], default: :en, current: :es)
+
+        model = Foo.create!(local_translations: { en: true, es: false })
+        model.local = true
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        results = CSV.read(import.file.path, headers: :first_row).map(&:to_h)
+
+        assert_equal(1, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        assert_equal('true', results.first['local'])
+
+        csv = Csv.new(import).import!
+        assert(model.reload.local)
+      end
+
+      def test_arrays
+        model = Foo.create!(bars: [{ array: %w(1 2) }])
+        model.bars.first.array = %w(3 4)
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        results = CSV.read(import.file.path, headers: :first_row).map(&:to_h)
+
+        assert_equal(1, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        assert_equal('3,4', results.first['bars_array'])
+
+        Csv.new(import).import!
+        assert_equal(%w(3 4), model.reload.bars.first.array)
+      end
+
+      def test_hashes
+        model = Foo.create!(baz: { hash_test: { 'foo' => %w(1 2) } })
+        model.baz.hash_test = { 'foo' => %w(3 4), 'bar' => '5' }
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        results = CSV.read(import.file.path, headers: :first_row).map(&:to_h)
+
+        assert_equal(1, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        assert_equal('3,4', results.first['baz_hash_test_foo'])
+        assert_equal('5', results.first['baz_hash_test_bar'])
+
+        Csv.new(import).import!
+        assert_equal(%w(3 4), model.reload.baz.hash_test['foo'])
+        assert_equal('5', model.reload.baz.hash_test['bar'])
+      end
+
+      def test_handles_variable_numbers_of_hashes
+        one = Foo.create!(baz: { hash_test: { 'foo' => %w(1 2) } })
+        two = Foo.create!(baz: { hash_test: { 'bar' => %w(3 4) } })
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize([one, two]), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        results = CSV.read(import.file.path, headers: :first_row).map(&:to_h)
+
+        assert_equal(2, results.size)
+        assert_equal(one.id.to_s, results.first['_id'])
+        assert_equal('1,2', results.first['baz_hash_test_foo'])
+        assert(results.first['baz_hash_test_bar'].blank?)
+
+        assert_equal(two.id.to_s, results.second['_id'])
+        assert_equal('3,4', results.second['baz_hash_test_bar'])
+        assert(results.second['baz_hash_test_foo'].blank?)
+
+        Csv.new(import).import!
+        assert_equal(%w(1 2), one.reload.baz.hash_test['foo'])
+        assert_equal(%w(3 4), two.reload.baz.hash_test['bar'])
+      end
+
+      def test_complex_embedded_hashes
+        model = Foo.create!(
+          baz: { hash_test: { 'foo' => %w(1 2) } },
+          bars: [
+            { hash_test: { 'bar' => %w(1 2) } },
+            { hash_test: { 'bar' => %w(3 4) } }
+          ]
+        )
+        model.baz.hash_test = { 'foo' => %w(3 4), 'bar' => '5' }
+        model.bars.first.hash_test = { 'foo' => %w(6 7) }
+        model.bars.second.hash_test = { 'bar' => %w(8 9), 'baz' => %(10), 'Qoo' => 'qux' }
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        results = CSV.read(import.file.path, headers: :first_row).map(&:to_h)
+
+        assert_equal(2, results.size)
+        assert_equal(model.id.to_s, results.first['_id'])
+        assert_equal('3,4', results.first['baz_hash_test_foo'])
+        assert_equal('5', results.first['baz_hash_test_bar'])
+        assert_equal('6,7', results.first['bars_hash_test_foo'])
+        assert_nil(results.first['bars_hash_test_bar'])
+        assert_nil(results.second['bars_hash_test_foo'])
+        assert_equal('8,9', results.second['bars_hash_test_bar'])
+        assert_equal('10', results.second['bars_hash_test_baz'])
+        assert_equal('qux', results.second['bars_hash_test_Qoo'])
+
+        Csv.new(import).import!
+        model.reload
+
+        assert_nil(model.hash_test)
+        assert_equal(%w(3 4), model.baz.hash_test['foo'])
+        assert_equal('5', model.baz.hash_test['bar'])
+        assert_equal(2, model.bars.first.hash_test.size)
+        assert_equal(%w(6 7), model.bars.first.hash_test['foo'])
+        assert_equal(%w(1 2), model.bars.first.hash_test['bar'])
+        assert_equal(3, model.bars.second.hash_test.size)
+        assert_equal(%w(8 9), model.bars.second.hash_test['bar'])
+        assert_equal('10', model.bars.second.hash_test['baz'])
+        assert_equal('qux', model.bars.second.hash_test['Qoo'])
+      end
+
+      def test_ignored_fields
+        Workarea.with_config do |config|
+          config.data_file_ignored_fields = %w(ignore)
+
+          model = Foo.create!(
+            bars: [{ name: '1', ignore: 1 }, { name: '2', ignore: 2 }]
+          )
+
+          csv = Csv.new.serialize(model)
+          results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+
+          assert_equal(2, results.size)
+          results.each { |r| refute(r.key?('bars_ignore')) }
+        end
+      end
+
+      def test_active_merchant_responses
+        model = Foo.create!(payment: ActiveMerchant::Billing::Response.new(true, 'foo'))
+
+        csv = Csv.new.serialize(model)
+        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+
+        assert_equal(1, results.size)
+        assert_equal('true', results.first['payment_success'])
+        assert_equal('foo', results.first['payment_message'])
+        assert_nil(results.first['payment_options_cvv_result'])
+      end
+
+      def test_failed_new_record_rows_with_subsequent_rows
+        Foo.validation_failure = true
+        model = Foo.new(bars: [{ name: 'one' }, { name: 'two' }])
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        Csv.new(import).import!
+        assert_equal(0, Foo.count)
+        assert_equal(2, import.total)
+        assert_equal(0, import.succeeded)
+        assert(import.file_errors['2'].present?)
+        refute(import.file_errors.key?('3'))
+
+      ensure
+        Foo.validation_failure = false
+      end
+
+      def test_blank_ids_on_embedded_documents
+        model = Foo.new(
+          bars: [{ id: '', name: '1' }, { id: '', name: '2' }],
+          baz: { id: '', name: '3' }
+        )
+
+        csv = Csv.new.serialize(model)
+        results = CSV.parse(csv, headers: :first_row).map(&:to_h)
+        assert(results.all? { |r| r['bars_id'].blank? && r['baz_id'].blank? })
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(csv, extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        Csv.new(import).import!
+        assert_equal(1, Foo.count)
+
+        model = Foo.first
+        assert(model.bars.map(&:id).all?(&:present?))
+        assert(model.baz.id.present?)
+        assert_equal(2, model.bars.size)
+      end
+
+      def test_embedded_documents_get_timestamps
+        model = Foo.new(
+          bars: [{ name: '1' }, { name: '2' }],
+          baz: { name: '3' }
+        )
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        Csv.new(import).import!
+        assert_equal(1, Foo.count)
+
+        model.reload
+        assert(model.bars.present?)
+        assert(model.bars.map(&:created_at).all?(&:present?))
+        assert(model.bars.map(&:updated_at).all?(&:present?))
+        assert(model.baz.created_at.present?)
+        assert(model.baz.updated_at.present?)
+      end
+
+      def test_blank_rows_are_ignored
+        model = Foo.new(id: nil)
+
+        import = create_import(
+          model_type: Foo.name,
+          file: create_tempfile(Csv.new.serialize(model), extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        Csv.new(import).import!
+        assert_equal(0, Foo.count)
+      end
+
+      def test_assign_dragonfly_attachment_attributes
+        VCR.use_cassette :csv_image_upload do
+          csv = "_id,bazzets_image_url\n,http://via.placeholder.com/350x150"
+          import = create_import(
+            model_type: Foo.name,
+            file: create_tempfile(csv, extension: 'csv'),
+            file_type: 'csv'
+          )
+
+          Csv.new(import).import!
+
+          assert_equal(1, Foo.count)
+          foo = Foo.first
+          assert_equal(1, foo.bazzets.count)
+          refute_nil(foo.bazzets.first.image_uid)
+        end
+      end
+
+      def test_assign_password_when_provided
+        csv = "_id,email,password\n,test@example.com,password1"
+        import = create_import(
+          model_type: User.name,
+          file: create_tempfile(csv, extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        assert_difference -> { User.count } do
+          Csv.new(import).import!
+          user = User.find_by_email('test@example.com')
+
+          assert user.present?, 'user not imported'
+          assert user.authenticate('password1'), 'password not imported'
+        end
+      end
+
+      def test_randomize_password_when_missing_and_new_record
+        csv = "_id,email,password\n,missing@example.com"
+        import = create_import(
+          model_type: User.name,
+          file: create_tempfile(csv, extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        assert_difference -> { User.count } do
+          Csv.new(import).import!
+          user = User.find_by_email('missing@example.com')
+
+          assert user.present?, 'user not imported'
+          refute user.authenticate('password1'),
+            "password authenticated when it shouldn't have"
+        end
+      end
+
+      def test_ignore_password_column_when_user_exists
+        user = create_user(first_name: 'Foo')
+        csv = "_id,email,password,first_name\n#{user.id},#{user.email},,Bar"
+        import = create_import(
+          model_type: User.name,
+          file: create_tempfile(csv, extension: 'csv'),
+          file_type: 'csv'
+        )
+
+        Csv.new(import).import!
+
+        assert_equal 'Bar', user.reload.first_name
+      end
+
+      def test_encoding_conversion
+        Workarea.with_config do |config|
+          config.csv_import_options[:encoding] = 'ISO-8859-1'
+          csv = %(_id,name,slug,details_keywords\n653911,Bowl Light#{153.chr},Bowl_Light,"testing")
+
+          import = create_import(
+            model_type: Catalog::Product.name,
+            file: create_tempfile(csv, extension: 'csv', encoding: 'ascii-8bit'),
+            file_type: 'csv'
+          )
+
+          Csv.new(import).import!
+
+          product = Catalog::Product.find_by(slug: 'bowl_light')
+          assert_equal("Bowl Light\u0099", product.name)
+        end
+      end
+    end
+  end
+end