axle_attributes 1.13.2

data/test/lib/definition/mappings_test.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class AxleAttributes::Definition::MappingsTest < ActiveSupport::TestCase
+  test 'to_options' do
+    definition = AxleAttributes::Definition.new Business, :repair_services
+    definition.mappings = {'bar' => 'Foo'}
+
+    assert_equal([['Foo', 'bar']], definition.to_options)
+  end
+
+  test 'attribute_mapping' do
+    attribute_mapping = create :attribute_mapping, namespace: 'Business', attribute_name: 'repair_services', label: 'Foo', value: 'bar'
+
+    definition = AxleAttributes::Definition.new Business, :repair_services
+
+    assert_equal({'bar' => 'Foo'}, definition.mappings)
+    assert_equal([attribute_mapping], definition.mapping_records)
+  end
+
+  test 'mapping_model' do
+    foo = AxleAttributes::Definition.new Business, :foo, mapping_model: 'Vegetable'
+
+    assert_equal Vegetable, foo.mapping_model
+    assert_equal(Vegetable.cached_mapping, foo.mappings)
+  end
+end

data/test/lib/definition_test.rb

@@ -0,0 +1,84 @@
+require 'helper'
+
+class AxleAttributes::DefinitionTest < ActiveSupport::TestCase
+  class TestModel
+    class << self
+      def name
+        'TestModel'
+      end
+    end
+  end
+
+  test 'filter_control' do
+    assert_equal 'text', AxleAttributes::Definition.new(TestModel, :foo, type: :string).filter_control
+    assert_equal 'range', AxleAttributes::Definition.new(TestModel, :foo, type: :integer).filter_control
+    assert_equal 'text', AxleAttributes::Definition.new(TestModel, :wtf, type: nil).filter_control
+    assert_equal 'combo', AxleAttributes::Definition.new(TestModel, :mapperoo, type: :string, mapping_model: 'Business').filter_control
+    assert_equal 'hierarchy', AxleAttributes::Definition.new(TestModel, :mapperoo, type: :string, mapping_model: 'SicCode').filter_control
+  end
+
+  test 'edit_control' do
+    assert_equal 'combo', AxleAttributes::Definition.new(TestModel, :bar, type: :boolean).edit_control
+    assert_equal 'textarea', AxleAttributes::Definition.new(TestModel, :bar, type: :text).edit_control
+    assert_equal 'filter', AxleAttributes::Definition.new(TestModel, :bar, type: :time).edit_control
+    assert_equal 'text', AxleAttributes::Definition.new(TestModel, :bar, type: :float).edit_control
+    assert_equal 'text', AxleAttributes::Definition.new(TestModel, :bar, type: :integer).edit_control
+    assert_equal 'text', AxleAttributes::Definition.new(TestModel, :bar, type: :string).edit_control
+
+    AxleAttributes::Definition.new(TestModel, :bar, type: :string).tap do |definition|
+      definition.mappings = {'foo' => 'bar'}
+      assert_equal 'combo', definition.edit_control
+    end
+  end
+
+  test 'aliases' do
+    foo = AxleAttributes::Definition.new TestModel, :foo, mmdb_name: 'hola'
+
+    assert_equal ['foo', 'hola', 'Foo'].to_set, foo.aliases.to_set
+  end
+
+  test 'to_param' do
+    assert_equal 'foo', AxleAttributes::Definition.new(TestModel, :foo, mmdb_name: 'hola').to_param
+  end
+
+  test 'namespace' do
+    assert_equal 'TestModel', AxleAttributes::Definition.new(TestModel, :foo).namespace
+  end
+
+  test 'type' do
+    foo = AxleAttributes::Definition.new TestModel, :foo, type: :string
+    assert_equal :string, foo.type
+  end
+
+  test 'format' do
+    foo = AxleAttributes::Definition.new TestModel, :foo, type: :string, format: :zip
+    assert_equal :zip, foo.format
+  end
+
+  test 'indexed' do
+    assert AxleAttributes::Definition.new(TestModel, :foo, index: true).indexed?
+    refute AxleAttributes::Definition.new(TestModel, :foo, index: false).indexed?
+  end
+
+  test 'versioned' do
+    assert AxleAttributes::Definition.new(TestModel, :foo, version: true).versioned?
+    refute AxleAttributes::Definition.new(TestModel, :foo).versioned?
+  end
+
+  test 'readonly' do
+    refute AxleAttributes::Definition.new(TestModel, :foo, type: :string).readonly?
+    refute AxleAttributes::Definition.new(TestModel, :foo, type: :string, editable: true).readonly?
+    assert AxleAttributes::Definition.new(TestModel, :foo, type: :string, editable: false).readonly?
+  end
+
+  test 'readonly when editable' do
+    attribute_customization = create :attribute_customization, name: 'foo', namespace: 'Business', editable: false
+    assert AxleAttributes::Definition.new(Business, :foo, type: :string).readonly?
+    refute AxleAttributes::Definition.new(Business, :bar, type: :string).readonly?
+  end
+
+  test 'readonly when deprecated' do
+    attribute_customization = create :attribute_customization, name: 'foo', namespace: 'Business', deprecated_on: Date.new
+    assert AxleAttributes::Definition.new(Business, :foo, type: :string, editable: true).readonly?
+  end
+end

data/test/lib/dumper_test.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+class AxleAttributes::DumperTest < ActiveSupport::TestCase
+  class TestModel
+    def self.attributes
+      {
+        'foo'   => AxleAttributes::ParentDefinition.new(self, 'foo',    type: :string, version: true),
+        'momma' => AxleAttributes::ParentDefinition.new(self, 'momma',  type: :integer, version: false),
+      }
+    end
+
+    def self.attribute_set
+      attributes.keys.to_set
+    end
+  end
+
+  test 'dump_internal' do
+    result = dumper.dump_internal
+
+    assert_match /Attribute,Display Name,Type,Deprecation/, result
+    assert_match Regexp.new('foo,Foo'), result
+    assert_match Regexp.new('momma,Momma'), result
+  end
+
+  test 'dump_public' do
+    result = dumper.dump_public(['foo'])
+
+    assert_match /Attribute,Display Name,Type,Description/, result
+    assert_match Regexp.new('foo,Foo'), result
+    refute_match Regexp.new('momma,Momma'), result
+  end
+
+  private
+
+    def dumper
+      @dumper ||= AxleAttributes::Dumper.new(TestModel)
+    end
+end

data/test/lib/format_test.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+class AxleAttributes::FormatTest < ActiveSupport::TestCase
+  test 'standardize_phone' do
+    assert_equal nil,               AxleAttributes::Format.standardize_phone(nil)
+    assert_equal 'too4few',         AxleAttributes::Format.standardize_phone('too4few')
+    assert_equal '(222) 456-7890',  AxleAttributes::Format.standardize_phone("2#2*2   \t4\n\n\n5()()()6.78====\\/===90!!!")
+    assert_equal '(123) 456-7890',  AxleAttributes::Format.standardize_phone('1234567890')
+    assert_equal '(123) 456-7890',  AxleAttributes::Format.standardize_phone(' (123) 456-7890 ')
+    assert_equal '(123) 456-7890',  AxleAttributes::Format.standardize_phone('1-123-456-7890 ')
+    assert_equal '(800) 356-9377',  AxleAttributes::Format.standardize_phone('1-800-FLOWERS')
+    assert_equal '(800) 356-9377',  AxleAttributes::Format.standardize_phone('1-800-flowers')
+    assert_equal 'some string that is not a phone number', AxleAttributes::Format.standardize_phone('some string that is not a phone number')
+  end
+
+  test 'standardize_postal_code' do
+    assert_equal nil, AxleAttributes::Format.standardize_postal_code(nil)
+    assert_equal '', AxleAttributes::Format.standardize_postal_code('')
+    assert_equal '12345', AxleAttributes::Format.standardize_postal_code('12345')
+    assert_equal '12345', AxleAttributes::Format.standardize_postal_code('123 45')
+    assert_equal '12345-6789', AxleAttributes::Format.standardize_postal_code('12345-6789')
+    assert_equal '12345-6789', AxleAttributes::Format.standardize_postal_code('123456789')
+    assert_equal 'H0H0H0', AxleAttributes::Format.standardize_postal_code('H0H0H0')
+    assert_equal 'H0H0H0', AxleAttributes::Format.standardize_postal_code('h0h0h0')
+    assert_equal 'H0H0H0', AxleAttributes::Format.standardize_postal_code('H0H 0H0')
+    assert_equal 'Bogus Value', AxleAttributes::Format.standardize_postal_code('Bogus Value')
+  end
+
+  test "standardize_url" do
+    assert_equal nil,                           AxleAttributes::Format.standardize_url(nil)
+    assert_equal '',                            AxleAttributes::Format.standardize_url('')
+    assert_equal 'website',                     AxleAttributes::Format.standardize_url('website')
+    assert_equal '@twitter',                    AxleAttributes::Format.standardize_url('@twitter')
+    assert_equal 'http://@twitter',             AxleAttributes::Format.standardize_url('http://@twitter')
+    assert_equal 'http://@twitter.com',         AxleAttributes::Format.standardize_url('http://@twitter.com')
+    assert_equal 'httpssss://www.twitter.com',  AxleAttributes::Format.standardize_url('httpssss://www.twitter.com')
+    assert_equal 'ftp://mywebsite.com',         AxleAttributes::Format.standardize_url('ftp://mywebsite.com')
+    assert_equal 'http:www.infogroup.com',      AxleAttributes::Format.standardize_url('http:www.infogroup.com')
+    assert_equal 'htp://www.infogroup.com',     AxleAttributes::Format.standardize_url('htp://www.infogroup.com')
+    assert_equal 'http::///www.infogroup.com',  AxleAttributes::Format.standardize_url('http::///www.infogroup.com')
+    assert_equal 'bad[twitter.com',             AxleAttributes::Format.standardize_url('bad[twitter.com')
+
+    assert_equal "http://www.infogroup.co.uk",  AxleAttributes::Format.standardize_url('http://www.infogroup.co.uk')
+    assert_equal "http://www.infogroup.co.uk",  AxleAttributes::Format.standardize_url('Http://www.infogroup.co.uk')
+    assert_equal "https://www.infogroup.co.uk", AxleAttributes::Format.standardize_url('https://www.infogroup.co.uk')
+    assert_equal "https://foo.com/xyz/%20yzz",  AxleAttributes::Format.standardize_url('https://foo.com/xyz/ yzz')
+    assert_equal "http://infogroup.co.uk",      AxleAttributes::Format.standardize_url('infogroup.co.uk')
+    assert_equal "http://infogroup.com",        AxleAttributes::Format.standardize_url('INFOGROUP.COM')
+    assert_equal "http://infogroup.com",        AxleAttributes::Format.standardize_url('http://infogroup.com  ')
+    assert_equal "http://infogroup.com/places/AbC123.html", AxleAttributes::Format.standardize_url('infogroup.com/places/AbC123.html')
+    assert_equal "http://infogroup.com/places/AbC%20123.html", AxleAttributes::Format.standardize_url('infogroup.com/places/AbC 123.html')
+    assert_equal "http://infogroup.com/places/AbC123.html", AxleAttributes::Format.standardize_url('infogroup.com/places/AbC123.html     ')
+    assert_equal "http://infogroup.com/places/AbC123.html?ids=47,99#GREATNESS", AxleAttributes::Format.standardize_url('infogroup.com/places/AbC123.html?ids=47,99#GREATNESS')
+    assert_equal "http://infogroup.com:8080/my/photo.png", AxleAttributes::Format.standardize_url('http://infogroup.com:8080/my/photo.png')
+    assert_equal "http://infogroup.com:65535",  AxleAttributes::Format.standardize_url('infogroup.com:65535')
+    assert_equal "http://infogroup.com",        AxleAttributes::Format.standardize_url('http://infogroup.com/')
+    assert_equal "http://infogroup.com/fun/time/", AxleAttributes::Format.standardize_url('http://infogroup.com/fun/time/')
+  end
+
+  test "url_regex" do
+    assert "http://infogroup.com".match AxleAttributes::Format.url_regex
+    assert "http://infogroup.com:65535".match AxleAttributes::Format.url_regex
+  end
+end

data/test/lib/has_attributes/json_reader_test.rb

@@ -0,0 +1,46 @@
+require 'helper'
+
+class AxleAttributes::HasAttributes::JsonReaderTest < ActiveSupport::TestCase
+  class Pet < Superstore::Base
+    include AxleAttributes::SerializedChild
+  end
+
+  class TestModel < Superstore::Base
+    include AxleAttributes::Model
+
+    class << self
+      def name
+        'TestModel'
+      end
+    end
+
+    json = {
+      'location' => {
+        'street'    => {'type' => 'string', 'format' => 'phone'}
+      },
+      'pets' => {
+        'class_name'  => 'AxleAttributes::HasAttributes::JsonReaderTest::Pet',
+        'type'        => 'serialize_many',
+        'attributes'  => {
+          'name'        => {'type' => 'string'},
+          'disposition' => {'type' => 'string'}
+        }
+      }
+    }
+
+    AxleAttributes::HasAttributes::JsonReader.read_definitions(TestModel, json, defaults: {index: true, version: false})
+  end
+
+  test 'simple definition' do
+    refute_nil TestModel.attributes['street']
+    assert_equal :string, TestModel.attributes['street'].options[:type]
+    assert_equal :phone, TestModel.attributes['street'].options[:format]
+    assert_equal true, TestModel.attributes['street'].options[:index]
+    assert_equal false, TestModel.attributes['street'].options[:version]
+  end
+
+  test 'serialization definition' do
+    refute_nil TestModel.serialization_reflections[:pets]
+    assert_equal :string, Pet.attributes['disposition'].options[:type]
+  end
+end

data/test/lib/has_attributes_test.rb

@@ -0,0 +1,69 @@
+require 'helper'
+
+class AxleAttributes::HasAttributesTest < ActiveSupport::TestCase
+  class TestModel
+    include AxleAttributes::HasAttributes
+
+    class << self
+      def name
+        'TestModel'
+      end
+
+      def reset!
+        attributes.clear
+        attribute_set.clear
+      end
+    end
+  end
+
+  setup do
+    TestModel.reset!
+  end
+
+  test 'has_attributes' do
+    TestModel.has_attributes foo: {}
+    assert_kind_of AxleAttributes::Definition, TestModel.attributes['foo']
+
+    TestModel.has_attributes({ bar: {} }, { editable: false })
+    assert TestModel.attributes['bar'].readonly?
+
+    TestModel.has_attributes({ baz: { editable: true } }, { editable: false })
+    refute TestModel.attributes['baz'].readonly?
+  end
+
+  test 'has_attribute' do
+    TestModel.has_attribute :foo
+    assert_kind_of AxleAttributes::Definition, TestModel.attributes['foo']
+    assert_equal ['foo'].to_set, TestModel.attribute_set
+  end
+
+  test 'has_mapping' do
+    TestModel.has_attribute :foo
+    TestModel.has_mapping :foo, %w(foo bar)
+    expected = {'foo' => 'Foo', 'bar' => 'Bar'}
+    assert_equal expected, TestModel.attributes['foo'].mappings
+  end
+
+  test 'has_attributes_file' do
+    attributes_file = Tempfile.new(['attributes', '.json'])
+    attributes_file.write({"speshal" => {"colors" => {"type" => "array"}}}.to_json)
+    attributes_file.rewind
+    TestModel.attributes_file_root = File.dirname(attributes_file.path)
+
+    TestModel.has_attributes_file File.basename(attributes_file.path, '.json')
+
+    assert_equal(:array, TestModel.attributes['colors'].type)
+    assert_equal File.basename(attributes_file.path, '.json'), TestModel.attributes['colors'].options[:filename]
+  end
+
+  test 'attribute inheritance' do
+    child_model = Class.new(TestModel)
+    child_model.has_attribute :foo, {}
+
+    assert child_model.attributes.key?('foo')
+    assert child_model.attribute_set.include?('foo')
+
+    assert !TestModel.attributes.key?('foo')
+    assert !TestModel.attribute_set.include?('foo')
+  end
+end

data/test/lib/model_test.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class AxleAttributes::ModelTest < ActiveSupport::TestCase
+  class Person < Superstore::Base
+    include AxleAttributes::Model
+  end
+
+  test 'definition_class' do
+    assert_equal '::AxleAttributes::ParentDefinition', Person.has_attribute_definition_class
+  end
+
+  test 'core attributes' do
+    refute_nil Person.attributes['created_at']
+    refute_nil Person.attributes['updated_at']
+    refute_nil Person.attributes['segment_id']
+
+    assert Person.attributes['created_at'].readonly?
+    assert Person.attributes['updated_at'].readonly?
+    assert Person.attributes['segment_id'].readonly?
+
+    assert_equal({type: "date", format: "dateOptionalTime", doc_values: true}, Person.elastic_index.mapping[:properties]['created_at'])
+    assert_equal({type: "date", format: "dateOptionalTime", doc_values: true}, Person.elastic_index.mapping[:properties]['updated_at'])
+    assert_equal({type: "long", doc_values: true}, Person.elastic_index.mapping[:properties]['segment_id'])
+  end
+
+  module Framework
+    class Base < Superstore::Base
+      include AxleAttributes::Model
+    end
+  end
+
+  class InheritedModel < Framework::Base
+  end
+
+  test 'core attribute inheritence' do
+    assert_nil Framework::Base.attributes['created_at']
+    assert_nil Framework::Base.attributes['updated_at']
+    assert_nil Framework::Base.attributes['segment_id']
+
+    refute_nil Person.attributes['created_at']
+    refute_nil Person.attributes['updated_at']
+    refute_nil Person.attributes['segment_id']
+  end
+end

data/test/lib/null_definition_test.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+class AxleAttributes::NullDefinitionTest < ActiveSupport::TestCase
+
+  test "reports the given name" do
+    assert_equal 'somename', AxleAttributes::NullDefinition.new(Business, 'somename').name
+  end
+
+  test "has a null type" do
+    assert_equal :null, AxleAttributes::NullDefinition.new(Business, 'whatzit').type
+  end
+
+  test "equality" do
+    definition1 = AxleAttributes::NullDefinition.new(Business, 'attr')
+    definition2 = AxleAttributes::NullDefinition.new(Business, 'attr')
+    assert_equal definition1, definition2
+
+    # definition1 = AxleAttributes::NullDefinition.new(Business, 'attr')
+    # definition2 = AxleAttributes::NullDefinition.new(Contact, 'attr')
+    # assert_not_equal definition1, definition2
+
+    definition1 = AxleAttributes::NullDefinition.new(Business, 'attr')
+    definition2 = AxleAttributes::NullDefinition.new(Business, 'different')
+    assert_not_equal definition1, definition2
+  end
+
+end

data/test/lib/parent_definition_test.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+class AxleAttributes::ParentDefinitionTest < ActiveSupport::TestCase
+  class TestModel < Superstore::Base
+    include AxleAttributes::Model
+
+    class << self
+      def reset!
+        elastic_index.mapping[:properties].clear
+        speshal_attributes.clear
+        versioned_attributes.clear
+      end
+
+      def base_class
+        TestModel
+      end
+
+      def attribute(name, options = {})
+        speshal_attributes[name] = options
+      end
+
+      def speshal_attributes
+        @@speshal_attributes ||= {}
+      end
+    end
+  end
+
+  setup do
+    TestModel.reset!
+  end
+
+  test 'attribute with blank' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo).setup!
+
+    assert_equal({}, TestModel.speshal_attributes)
+  end
+
+  test 'attribute with default' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo, type: :integer, default: 42).setup!
+
+    assert_equal({'foo' => {type: :integer, default: 42}}, TestModel.speshal_attributes)
+  end
+
+  test 'attribute with type integer' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo, type: :integer).setup!
+
+    assert_equal({'foo' => {type: :integer}}, TestModel.speshal_attributes)
+  end
+
+  test 'attribute with type text' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo, type: :text).setup!
+
+    assert_equal({'foo' => {type: :string}}, TestModel.speshal_attributes)
+  end
+
+  test 'setup index' do
+    definition = AxleAttributes::ParentDefinition.new(TestModel, :foo, type: :string, index: :snowball)
+
+    definition.setup!
+
+    assert_equal definition.index_mapping, TestModel.elastic_index.mapping[:properties]['foo']
+  end
+
+  test 'version with false' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo, version: false).setup!
+
+    assert_equal [].to_set, TestModel.versioned_attributes
+  end
+
+  test 'version with true' do
+    AxleAttributes::ParentDefinition.new(TestModel, :foo, version: true).setup!
+
+    assert_equal ['foo'].to_set, TestModel.versioned_attributes
+  end
+end