nokogiri-happymapper 0.8.1 → 0.9.0

data/spec/happymapper/anonymous_mapper_spec.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe HappyMapper::AnonymousMapper do
-  let(:anonymous_mapper) { described_class.new }
-
-  describe '#parse' do
-    context 'when parsing a single root node' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('address.xml') }
-
-      it 'creates the correct set of child elements on the element class' do
-        elements = parsed_result.class.elements
-        expect(elements.map(&:tag)).to eq %w(street housenumber postcode city country state)
-      end
-
-      it 'parses child elements' do
-        aggregate_failures do
-          expect(parsed_result.street).to eq('Milchstrasse')
-          expect(parsed_result.housenumber).to eq('23')
-          expect(parsed_result.postcode).to eq('26131')
-          expect(parsed_result.city).to eq('Oldenburg')
-        end
-      end
-
-      it 'does not create a content entry when the xml contents no text content' do
-        expect(parsed_result).not_to respond_to :content
-      end
-
-      it 'parses both the attributes and content when present' do
-        aggregate_failures do
-          expect(parsed_result.country.code).to eq('de')
-          expect(parsed_result.country.content).to eq('Germany')
-        end
-      end
-    end
-
-    context 'with element names with special characters' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('ambigous_items.xml') }
-
-      it 'creates accessor methods with similar names' do
-        expect(parsed_result.my_items.item).to be_kind_of Array
-      end
-    end
-
-    context 'with element names with camelCased elements and Capital Letters' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('subclass_namespace.xml') }
-
-      it 'parses camel-cased child elements correctly' do
-        aggregate_failures do
-          expect(parsed_result.photo.publish_options.author).to eq('Stephanie')
-          expect(parsed_result.gallery.photo.title).to eq('photo title')
-        end
-      end
-
-      it 'parses camel-cased child properties correctly' do
-        expect(parsed_result.publish_options.created_day).to eq('2011-01-14')
-      end
-    end
-
-    context 'with repeated elements with camel-cased names' do
-      let(:xml) do
-        <<~XML
-          <foo>
-            <fooBar>
-              <baz>Hello</baz>
-            </fooBar>
-            <fooBar>
-              <baz>Hi</baz>
-            </fooBar>
-          </foo>
-        XML
-      end
-      let(:parsed_result) { anonymous_mapper.parse xml }
-
-      it 'parses the repeated elements correctly' do
-        expect(parsed_result.foo_bar.map(&:baz)).to eq %w(Hello Hi)
-      end
-    end
-
-    context 'with elements with camelCased attribute names' do
-      let(:parsed_result) { anonymous_mapper.parse '<foo barBaz="quuz"/>' }
-
-      it 'parses attributes correctly' do
-        expect(parsed_result.bar_baz).to eq('quuz')
-      end
-    end
-
-    context 'with several elements nested deeply' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('ambigous_items.xml') }
-
-      it 'parses the entire relationship' do
-        expect(parsed_result.my_items.item.first.item.name).to eq('My first internal item')
-      end
-    end
-
-    context 'when parsing an that contains multiple elements with the same tag' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('multiple_primitives.xml') }
-
-      it "parses the elements as it would a 'has_many'" do
-        aggregate_failures do
-          expect(parsed_result.name).to eq('value')
-          expect(parsed_result.image).to eq(%w(image1 image2))
-        end
-      end
-    end
-
-    context 'when parsing xml with multiple namespaces' do
-      let(:parsed_result) { anonymous_mapper.parse fixture_file('subclass_namespace.xml') }
-
-      it 'parses the elements an values correctly' do
-        expect(parsed_result.title).to eq('article title')
-      end
-
-      it 'parses attribute names correctly' do
-        expect(parsed_result.name).to eq 'title'
-      end
-    end
-
-    context 'when parsing an element with a nested value element with a different namespace' do
-      let(:xml) do
-        <<~XML
-          <a:foo xmlns:a="http://foo.org/a" xmlns:b="http://foo.org/b">
-            <b:bar>Hello</b:bar>
-          </a:foo>
-        XML
-      end
-      let(:result) { anonymous_mapper.parse xml }
-
-      it 'parses the value elements correctly' do
-        expect(result.bar).to eq 'Hello'
-      end
-    end
-
-    context 'when parsing xml that uses the same tag for string and other elements' do
-      let(:xml) do
-        <<~XML
-          <foo>
-            <bar>
-              <baz>Hello</baz>
-            </bar>
-            <baz>
-              <qux>Hi</qux>
-            </baz>
-          </foo>
-        XML
-      end
-      let(:result) { anonymous_mapper.parse xml }
-
-      it 'parses both occurences of the tag correctly' do
-        aggregate_failures do
-          expect(result.bar.baz).to eq 'Hello'
-          expect(result.baz.qux).to eq 'Hi'
-        end
-      end
-    end
-  end
-end

data/spec/happymapper/attribute_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe HappyMapper::Attribute do
-  describe 'initialization' do
-    it 'accepts :default option' do
-      attr = described_class.new(:foo, String, default: 'foobar')
-      expect(attr.default).to eq('foobar')
-    end
-  end
-end

data/spec/happymapper/item_spec.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Foo
-  class Bar; end
-end
-
-describe HappyMapper::Item do
-  describe 'new instance' do
-    before do
-      @item = described_class.new(:foo, String, tag: 'foobar')
-    end
-
-    it 'accepts a name' do
-      expect(@item.name).to eq('foo')
-    end
-
-    it 'accepts a type' do
-      expect(@item.type).to eq(String)
-    end
-
-    it 'accepts :tag as an option' do
-      expect(@item.tag).to eq('foobar')
-    end
-
-    it 'has a method_name' do
-      expect(@item.method_name).to eq('foo')
-    end
-  end
-
-  describe '#constant' do
-    it 'justs use type if constant' do
-      item = described_class.new(:foo, String)
-      expect(item.constant).to eq(String)
-    end
-
-    it 'converts string type to constant' do
-      item = described_class.new(:foo, 'String')
-      expect(item.constant).to eq(String)
-    end
-
-    it 'converts string with :: to constant' do
-      item = described_class.new(:foo, 'Foo::Bar')
-      expect(item.constant).to eq(Foo::Bar)
-    end
-  end
-
-  describe '#method_name' do
-    it 'converts dashes to underscores' do
-      item = described_class.new(:'foo-bar', String, tag: 'foobar')
-      expect(item.method_name).to eq('foo_bar')
-    end
-  end
-
-  describe '#xpath' do
-    it 'defaults to tag' do
-      item = described_class.new(:foo, String, tag: 'foobar')
-      expect(item.xpath).to eq('foobar')
-    end
-
-    it 'prepends with .// if options[:deep] true' do
-      item = described_class.new(:foo, String, tag: 'foobar', deep: true)
-      expect(item.xpath).to eq('.//foobar')
-    end
-
-    it 'prepends namespace if namespace exists' do
-      item = described_class.new(:foo, String, tag: 'foobar')
-      item.namespace = 'v2'
-      expect(item.xpath).to eq('v2:foobar')
-    end
-  end
-
-  describe 'typecasting' do
-    it 'works with Strings' do
-      item = described_class.new(:foo, String)
-      [21, '21'].each do |a|
-        expect(item.typecast(a)).to eq('21')
-      end
-    end
-
-    context 'with Integers' do
-      let(:item) { described_class.new(:foo, Integer) }
-
-      it 'works with an integer' do
-        expect(item.typecast(21)).to eq 21
-      end
-
-      it 'works with a float' do
-        expect(item.typecast(21.0)).to eq 21
-      end
-
-      it 'works with a string' do
-        expect(item.typecast('21')).to eq 21
-      end
-
-      it 'works with a string with trailing characters' do
-        expect(item.typecast('21foo')).to eq 21
-      end
-
-      it 'works with a string with zero plus trailing characters' do
-        expect(item.typecast('0foo')).to eq 0
-      end
-
-      it 'handles a non-numeric string' do
-        expect(item.typecast('foo')).to be_nil
-      end
-
-      it 'handles an empty string' do
-        expect(item.typecast('')).to be_nil
-      end
-
-      it 'handles nil' do
-        expect(item.typecast(nil)).to be_nil
-      end
-    end
-
-    it 'works with Floats' do
-      item = described_class.new(:foo, Float)
-      [21, 21.0, '21'].each do |a|
-        expect(item.typecast(a)).to eq 21.0
-      end
-    end
-
-    it 'works with Times' do
-      item = described_class.new(:foo, Time)
-      expect(item.typecast('2000-01-01 01:01:01.123456')).to eq(Time.local(2000, 1, 1, 1, 1, 1, 123_456))
-    end
-
-    context 'with Date' do
-      let(:item) { described_class.new(:foo, Date) }
-
-      it 'works with a string' do
-        expect(item.typecast('2000-01-01')).to eq(Date.new(2000, 1, 1))
-      end
-
-      it 'handles nil' do
-        expect(item.typecast(nil)).to be_nil
-      end
-
-      it 'handles empty string' do
-        expect(item.typecast('')).to eq(nil)
-      end
-    end
-
-    context 'with DateTime' do
-      let(:item) { described_class.new(:foo, DateTime) }
-
-      it 'works with a string' do
-        result = item.typecast('2000-01-01 13:42:37')
-        expect(result.to_time).to eq Time.new(2000, 1, 1, 13, 42, 37, '+00:00')
-      end
-
-      it 'works with a historical date in a string' do
-        result = item.typecast('1616-04-23')
-
-        aggregate_failures do
-          expect(result.to_time).to eq Time.new(1616, 4, 23, 0, 0, 0, '+00:00')
-          expect(result).to be_gregorian
-        end
-      end
-
-      it 'handles nil' do
-        expect(item.typecast(nil)).to eq(nil)
-      end
-
-      it 'handles empty strings' do
-        expect(item.typecast('')).to eq(nil)
-      end
-    end
-
-    it 'works with Boolean' do
-      item = described_class.new(:foo, HappyMapper::Boolean)
-      expect(item.typecast('false')).to eq(false)
-    end
-  end
-end