eapi 0.1.2 → 0.2.0

data/spec/basic_spec.rb

@@ -4,55 +4,56 @@ RSpec.describe Eapi do
 
   context 'basic behaviour' do
     class MyTestKlass
-      include Eapi::Common
-
+      include Eapi::Item
       property :something
     end
 
-    describe '#something (fluent setter/getter)' do
-      describe '#something as getter' do
-        it 'return the value' do
-          eapi = MyTestKlass.new something: :hey
-          expect(eapi.something).to eq :hey
+    describe MyTestKlass do
+      describe '#something (fluent setter/getter)' do
+        describe '#something as getter' do
+          it 'return the value' do
+            eapi = described_class.new something: :hey
+            expect(eapi.something).to eq :hey
+          end
         end
-      end
 
-      describe '#something("val")' do
-        it 'set the value and return self' do
-          eapi = MyTestKlass.new something: :hey
-          res  = eapi.something :other
-          expect(eapi).to be res
-          expect(eapi.something).to eq :other
+        describe '#something("val")' do
+          it 'set the value and return self' do
+            eapi = described_class.new something: :hey
+            res  = eapi.something :other
+            expect(eapi).to be res
+            expect(eapi.something).to eq :other
+          end
         end
-      end
 
-      describe '#set_something("val")' do
-        it 'set the value and return self' do
-          eapi = MyTestKlass.new something: :hey
-          res  = eapi.set_something :other
-          expect(eapi).to be res
-          expect(eapi.something).to eq :other
+        describe '#set_something("val")' do
+          it 'set the value and return self' do
+            eapi = described_class.new something: :hey
+            res  = eapi.set_something :other
+            expect(eapi).to be res
+            expect(eapi.something).to eq :other
+          end
         end
       end
-    end
 
-    describe '#get' do
-      it 'will use the getter' do
-        eapi = MyTestKlass.new something: :hey
-        expect(eapi.get(:something)).to eq :hey
-        expect(eapi.get('something')).to eq :hey
-      end
+      describe '#get' do
+        it 'will use the getter' do
+          eapi = described_class.new something: :hey
+          expect(eapi.get(:something)).to eq :hey
+          expect(eapi.get('something')).to eq :hey
+        end
 
-    end
+      end
 
-    describe '#set' do
-      it 'will use the fluent setter' do
-        eapi = MyTestKlass.new
-        expect(eapi.set(:something, :hey)).to equal eapi
-        expect(eapi.get(:something)).to eq :hey
+      describe '#set' do
+        it 'will use the fluent setter' do
+          eapi = described_class.new
+          expect(eapi.set(:something, :hey)).to equal eapi
+          expect(eapi.get(:something)).to eq :hey
+        end
       end
-    end
 
+    end
   end
 
 end

data/spec/definition_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Eapi do
 
   context '#definition_for' do
     class MyTestKlassDefinition
-      include Eapi::Common
+      include Eapi::Item
 
       property :something, type: Hash, unrecognised_option: 1
     end

data/spec/extension_spec.rb

@@ -8,14 +8,14 @@ RSpec.describe Eapi do
     end
 
     class MyExtensionExternalKlass
-      include MyExtension::Common
+      include MyExtension::Item
 
       property :something
     end
 
     module MyExtension
       class TestKlass
-        include MyExtension::Common
+        include MyExtension::Item
 
         property :something
       end

data/spec/function_spec.rb

@@ -2,63 +2,92 @@ require 'spec_helper'
 
 RSpec.describe Eapi do
 
-  context 'function initializer' do
-    class MyTestKlassOutside
-      include Eapi::Common
+  class MyTestKlassOutside
+    include Eapi::Item
+
+    property :something
+  end
+
+  class MyTestListOutside
+    include Eapi::List
+  end
+
+  module Somewhere
+    class TestKlassInModule
+      include Eapi::Item
 
       property :something
     end
 
-    module Somewhere
-      class TestKlassInModule
-        include Eapi::Common
+    class TestListInModule
+      include Eapi::List
+    end
+  end
 
-        property :something
+  describe 'Eapi::Children' do
+    describe '#list' do
+      it 'returns the list of Eapi enabled classes' do
+        list = Eapi::Children.list
+        expect(list).to include(MyTestKlassOutside)
+        expect(list).to include(MyTestListOutside)
       end
     end
 
-    describe 'Eapi::Children' do
-      describe '#list' do
-        it 'returns the list of Eapi enabled classes' do
-          list = Eapi::Children.list
-          expect(list).to include(MyTestKlassOutside)
-        end
+    describe '#has?' do
+      it 'true if the given class is an Eapi enabled class' do
+        expect(Eapi::Children).not_to be_has('nope')
+        expect(Eapi::Children).to be_has(MyTestKlassOutside)
+        expect(Eapi::Children).to be_has('MyTestKlassOutside')
+        expect(Eapi::Children).to be_has('my_test_klass_outside')
+        expect(Eapi::Children).to be_has(MyTestListOutside)
+        expect(Eapi::Children).to be_has('MyTestListOutside')
+        expect(Eapi::Children).to be_has('my_test_list_outside')
       end
+    end
 
-      describe '#has?' do
-        it 'true if the given class is an Eapi enabled class' do
-          expect(Eapi::Children).not_to be_has('nope')
-          expect(Eapi::Children).to be_has(MyTestKlassOutside)
-          expect(Eapi::Children).to be_has('MyTestKlassOutside')
-          expect(Eapi::Children).to be_has('my_test_klass_outside')
-        end
+    describe '#get' do
+      it 'get the given class if it is an Eapi enabled class' do
+        expect(Eapi::Children.get('nope')).to be_nil
+        expect(Eapi::Children.get(MyTestKlassOutside)).to eq MyTestKlassOutside
+        expect(Eapi::Children.get('MyTestKlassOutside')).to eq MyTestKlassOutside
+        expect(Eapi::Children.get('my_test_klass_outside')).to eq MyTestKlassOutside
+        expect(Eapi::Children.get(MyTestListOutside)).to eq MyTestListOutside
+        expect(Eapi::Children.get('MyTestListOutside')).to eq MyTestListOutside
+        expect(Eapi::Children.get('my_test_list_outside')).to eq MyTestListOutside
       end
+    end
+  end
 
-      describe '#get' do
-        it 'get the given class if it is an Eapi enabled class' do
-          expect(Eapi::Children.get('nope')).to be_nil
-          expect(Eapi::Children.get(MyTestKlassOutside)).to eq MyTestKlassOutside
-          expect(Eapi::Children.get('MyTestKlassOutside')).to eq MyTestKlassOutside
-          expect(Eapi::Children.get('my_test_klass_outside')).to eq MyTestKlassOutside
+  describe 'initialise using method calls to Eapi', :focus do
+    [
+      [:MyTestKlassOutside, MyTestKlassOutside],
+      [:my_test_klass_outside, MyTestKlassOutside],
+      [:Somewhere__TestKlassInModule, Somewhere::TestKlassInModule],
+      [:somewhere__test_klass_in_module, Somewhere::TestKlassInModule],
+      [:Somewhere_TestKlassInModule, Somewhere::TestKlassInModule],
+      [:somewhere_test_klass_in_module, Somewhere::TestKlassInModule],
+    ].each do |(meth, klass)|
+      describe "Eapi.#{meth}(...)" do
+        it "calls #{klass}.new" do
+          eapi = Eapi.send meth, something: :hey
+          expect(eapi).to be_a klass
+          expect(eapi.something).to eq :hey
         end
       end
     end
 
-    describe 'initialise using method calls to Eapi', :focus do
-      [
-        [:MyTestKlassOutside, MyTestKlassOutside],
-        [:my_test_klass_outside, MyTestKlassOutside],
-        [:Somewhere__TestKlassInModule, Somewhere::TestKlassInModule],
-        [:somewhere__test_klass_in_module, Somewhere::TestKlassInModule],
-        [:Somewhere_TestKlassInModule, Somewhere::TestKlassInModule],
-        [:somewhere_test_klass_in_module, Somewhere::TestKlassInModule],
-      ].each do |(meth, klass)|
-        describe "Eapi.#{meth}(...)" do
-          it "calls #{klass}.new" do
-            eapi = Eapi.send meth, something: :hey
-            expect(eapi).to be_a klass
-            expect(eapi.something).to eq :hey
-          end
+    [
+      [:MyTestListOutside, MyTestListOutside],
+      [:my_test_list_outside, MyTestListOutside],
+      [:Somewhere__TestListInModule, Somewhere::TestListInModule],
+      [:somewhere__test_list_in_module, Somewhere::TestListInModule],
+      [:Somewhere_TestListInModule, Somewhere::TestListInModule],
+      [:somewhere_test_list_in_module, Somewhere::TestListInModule],
+    ].each do |(meth, klass)|
+      describe "Eapi.#{meth}(...)" do
+        it "calls #{klass}.new" do
+          eapi = Eapi.send meth
+          expect(eapi).to be_a klass
         end
       end
     end

data/spec/list_elements_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'list elements' do
+    class MyTestClassValMult
+      include Eapi::Item
+
+      property :something, multiple: true
+    end
+
+    it '#add_something' do
+      eapi = MyTestClassValMult.new something: [1, 2]
+      res  = eapi.add_something 3
+      expect(res).to be eapi
+      expect(eapi.something).to eq [1, 2, 3]
+    end
+
+    it '#init_something called on first add if element is nil' do
+      eapi = MyTestClassValMult.new
+      res  = eapi.add_something :a
+      expect(res).to be eapi
+      expect(eapi.something.to_a).to eq [:a]
+    end
+
+    class MyTestClassValMultImpl
+      include Eapi::Item
+
+      property :something, type: Set
+    end
+
+    class MyMultiple
+      def self.is_multiple?
+        true
+      end
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class MyTestClassValMultImpl2
+      include Eapi::Item
+
+      property :something, type: MyMultiple
+    end
+
+    class MyMultipleValueTestKlass
+      include Eapi::MultipleValue
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class MyTestClassValMultImpl3
+      include Eapi::Item
+
+      property :something, type: MyMultipleValueTestKlass
+    end
+
+    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
+      [
+        [MyTestClassValMult, Array],
+        [MyTestClassValMultImpl, Set],
+        [MyTestClassValMultImpl2, MyMultiple],
+        [MyTestClassValMultImpl3, MyMultipleValueTestKlass],
+      ].each do |(eapi_class, type_class)|
+        eapi = eapi_class.new
+        res  = eapi.add_something :a
+        expect(res).to be eapi
+        expect(eapi.something.to_a).to eq [:a]
+        expect(eapi.something).to be_a_kind_of type_class
+      end
+    end
+
+    describe 'element validation' do
+      class MyTestClassValElements
+        include Eapi::Item
+        property :something, multiple: true, element_type: Hash
+        property :other, multiple: true, validate_element_with: ->(record, attr, value) do
+          record.errors.add(attr, "element must pass my custom validation") unless value == :valid_val
+        end
+      end
+
+      describe 'using `type_element` property in definition' do
+        it 'will validate the type of all the elements in the list' do
+          eapi = MyTestClassValElements.new
+          eapi.add_something 1
+          expect(eapi).not_to be_valid
+          expect(eapi.errors.full_messages).to eq ["Something element must be a Hash"]
+          expect(eapi.errors.messages).to eq({something: ["element must be a Hash"]})
+
+          eapi.something [{a: :b}]
+          expect(eapi).to be_valid
+        end
+      end
+
+      describe 'using `validate_element_with` property in definition' do
+        it 'will run that custom validation for all the elements in the list' do
+          eapi = MyTestClassValElements.new
+          eapi.add_other 1
+          expect(eapi).not_to be_valid
+          expect(eapi.errors.full_messages).to eq ["Other element must pass my custom validation"]
+          expect(eapi.errors.messages).to eq({other: ["element must pass my custom validation"]})
+
+          eapi.other [:valid_val]
+          expect(eapi).to be_valid
+        end
+      end
+    end
+  end
+end

data/spec/list_spec.rb

@@ -3,122 +3,419 @@ require 'spec_helper'
 RSpec.describe Eapi do
 
   context 'list' do
-    class MyTestClassValMult
-      include Eapi::Common
 
-      property :something, multiple: true
+    class MyListKlass
+      include Eapi::List
     end
 
-    it '#add_something' do
-      eapi = MyTestClassValMult.new something: [1, 2]
-      res  = eapi.add_something 3
-      expect(res).to be eapi
-      expect(eapi.something).to eq [1, 2, 3]
-    end
-
-    it '#init_something called on first add if element is nil' do
-      eapi = MyTestClassValMult.new
-      res  = eapi.add_something :a
-      expect(res).to be eapi
-      expect(eapi.something.to_a).to eq [:a]
-    end
-
-    class MyTestClassValMultImpl
-      include Eapi::Common
-
-      property :something, type: Set
-    end
+    describe 'list behaviour' do
+      subject { MyListKlass.new }
 
-    class MyMultiple
-      def self.is_multiple?
-        true
+      context '#<<' do
+        it 'append element, normal behaviour' do
+          res = subject << :hey
+          expect(res).to eq [:hey]
+          expect(subject.to_a).to eq [:hey]
+        end
       end
 
-      def <<(x)
-        @elements ||= []
-        @elements << x
+      context '#add' do
+        it 'fluent adder, returns self' do
+          res = subject.add(:hey).add(:you)
+          expect(res).to eq subject
+          expect(subject.to_a).to eq [:hey, :you]
+        end
       end
 
-      def to_a
-        @elements.to_a
+      context '#to_a' do
+        it 'executes validation' do
+
+        end
       end
     end
 
-    class MyTestClassValMultImpl2
-      include Eapi::Common
+    describe 'list methods' do
+      KNOWN_METHODS = {
+        not_supported: [:transpose, :assoc, :rassoc, :permutation, :combination, :repeated_permutation, :repeated_combination, :product, :pack],
+        not_same:      [:pry, :to_s, :inspect, :to_a, :to_h, :hash, :eql?, :to_ary, :pretty_print, :pretty_print_cycle],
+        block:         [:cycle, :each, :each_index, :reverse_each],
+        special:       [:[], :[]=, :<<, :==],
+        other_array:   [:concat, :+, :-, :&, :|, :replace, :<=>],
+        at:            [:at, :fetch, :delete_at, :from, :to],
+        index:         [:index, :find_index, :rindex, :delete],
+        push:          [:push, :unshift, :append, :prepend],
+        insert:        [:insert],
+        map:           [:map, :map!, :collect!, :collect],
+        select!:       [:keep_if, :select!, :reject!, :select, :delete_if, :reject, :drop_while, :take_while, :bsearch],
+        by_number:     [:in_groups_of, :in_groups, :drop, :take, :include?, :*, :to_query, :fill],
+        slice:         [:slice, :slice!],
+        sort_by:       [:sort_by!],
+        sample:        [:sample],
+        shuffle:       [:shuffle, :shuffle!],
+      }
 
-      property :something, type: MyMultiple
-    end
+      SUPPORTED_METHODS = [].public_methods(false) - KNOWN_METHODS[:not_supported]
+      MIMIC_METHODS     = [].public_methods(false) - KNOWN_METHODS.values.flatten
 
-    class MyMultipleEapi
-      include Eapi::Multiple
+      subject { MyListKlass.new.add(1).add(2).add(3) }
+      let(:other) { MyListKlass.new.add(1).add(2).add(3) }
+      let(:array) { [1, 2, 3] }
 
-      def <<(x)
-        @elements ||= []
-        @elements << x
-      end
+      context 'array methods' do
+        describe 'respond to methods' do
+          KNOWN_METHODS[:not_supported].each do |m|
+            it "does not respond to #{m}" do
+              expect(subject).not_to respond_to(m)
+            end
+          end
+
+          SUPPORTED_METHODS.each do |m|
+            it "responds to #{m}" do
+              expect(subject).to respond_to(m)
+            end
+          end
+        end
+
+        describe 'same behaviour as list array' do
+
+          describe 'to_ary' do
+            it { expect(subject.to_ary).to eq array }
+            it { expect(subject.to_ary).not_to equal subject }
+            it { expect(subject.to_ary).to equal subject._list }
+          end
+
+          describe 'method ==' do
+            it { expect(subject).to eq array }
+            it { expect(subject).to eq other }
+            it { expect(subject).not_to eq [3, 2, 1] }
+            it { expect(subject).not_to eq MyListKlass.new }
+          end
+
+          describe 'method []' do
+            it { expect(subject[2]).to eq array[2] }
+          end
+
+          describe 'method []=' do
+            it { expect(subject[2] = :paco).to eq(array[2] = :paco) }
+            it do
+              subject[2] = :paco
+              expect(subject[2]).to eq :paco
+            end
+          end
+
+          describe 'method <<' do
+            it { expect(subject << :paco).to eq(array << :paco) }
+            it do
+              subject << :paco
+              expect(subject.last).to eq :paco
+            end
+          end
+
+          KNOWN_METHODS[:other_array].each do |m|
+            describe "method #{m}" do
+              it { expect(subject.public_send(m, other)).to eq array.public_send(m, other._list) }
+              it { expect(subject.public_send(m, other._list)).to eq(array.public_send(m, other._list)) }
+            end
+          end
+
+
+          KNOWN_METHODS[:at].each do |m|
+            describe "method #{m}" do
+              it { expect(subject.public_send(m, 2)).to eq array.public_send(m, 2) }
+            end
+          end
+
+          KNOWN_METHODS[:index].each do |m|
+            describe "method #{m}" do
+              it { expect(subject.public_send(m, 2)).to eq array.public_send(m, 2) }
+            end
+          end
+
+          KNOWN_METHODS[:push].each do |m|
+            describe "method #{m}" do
+              it { expect(subject.public_send(m, :paco)).to eq(array.public_send(m, :paco)) }
+              it do
+                subject.public_send(m, :paco)
+                array.public_send(m, :paco)
+                expect(subject).to eq array
+              end
+            end
+          end
+
+          KNOWN_METHODS[:insert].each do |m|
+            describe "method #{m}" do
+              it { expect(subject.public_send(m, 1, :paco)).to eq(array.public_send(m, 1, :paco)) }
+              it do
+                subject.public_send(m, 1, :paco)
+                array.public_send(m, 1, :paco)
+                expect(subject).to eq array
+              end
+            end
+          end
+
+          describe "method sample" do
+            it do
+              expect(subject._list).to include(subject.sample)
+            end
+          end
+
+          describe "method shuffle" do
+            it do
+              list_before_shuffle = subject._list.dup
+              list_after_shuffle  = subject.shuffle._list.dup
+              expect(list_before_shuffle.sort).to eq list_after_shuffle.sort
+            end
+          end
+
+          describe "method shuffle!" do
+            it do
+              list_before_shuffle = subject._list.dup
+              subject.shuffle!
+              list_after_shuffle = subject._list.dup
+              expect(list_before_shuffle.sort).to eq list_after_shuffle.sort
+            end
+          end
+
+
+          KNOWN_METHODS[:map].each do |m|
+            describe "method #{m}" do
+              let(:subject_applied_block) do
+                subject.public_send(m) { |x| x + 1 }
+              end
+
+              let(:array_applied_block) do
+                array.public_send(m) { |x| x + 1 }
+              end
+
+              it do
+                expect(subject_applied_block).to eq array_applied_block
+              end
+
+              it do
+                subject_applied_block
+                array_applied_block
+                expect(subject).to eq array
+              end
+            end
+          end
+
+
+          KNOWN_METHODS[:select!].each do |m|
+            describe "method #{m}" do
+              let(:subject_applied_block) do
+                subject.public_send(m) { |x| x.odd? }
+              end
+
+              let(:array_applied_block) do
+                array.public_send(m) { |x| x.odd? }
+              end
+
+              it do
+                expect(subject_applied_block).to eq array_applied_block
+              end
+
+              it do
+                subject_applied_block
+                array_applied_block
+                expect(subject).to eq array
+              end
+            end
+          end
+
+
+          KNOWN_METHODS[:by_number].each do |m|
+            describe "method #{m}" do
+              let(:subject_result) do
+                subject.public_send(m, 2)
+              end
+
+              let(:array_result) do
+                array.public_send(m, 2)
+              end
 
-      def to_a
-        @elements.to_a
+              it do
+                expect(subject_result).to eq array_result
+              end
+
+              it do
+                subject_result
+                array_result
+                expect(subject).to eq array
+              end
+            end
+          end
+
+
+          KNOWN_METHODS[:slice].each do |m|
+            describe "method #{m}" do
+              let(:subject_result) do
+                subject.public_send(m, 2)
+              end
+
+              let(:array_result) do
+                array.public_send(m, 2)
+              end
+
+              it do
+                expect(subject_result).to eq array_result
+              end
+
+              it do
+                subject_result
+                array_result
+                expect(subject).to eq array
+              end
+            end
+          end
+
+          describe "method sort_by!" do
+            let(:subject_enumerator) do
+              subject.sort_by!
+            end
+
+            let(:array_enumerator) do
+              array.sort_by!
+            end
+
+            let(:subject_with_block) do
+              subject.sort_by! { |x| -1 * x }
+            end
+
+            let(:array_with_block) do
+              array.sort_by! { |x| -1 * x }
+            end
+
+            it do
+              expect(subject_enumerator.to_a).to eq array_enumerator.to_a
+            end
+
+            it do
+              expect(subject_with_block.to_a).to eq array_with_block.to_a
+            end
+
+            it do
+              subject_with_block
+              array_with_block
+              expect(subject).to eq array
+            end
+          end
+
+
+          describe 'block methods' do
+            describe 'method cycle' do
+              it 'behaves like the method in Array' do
+                sl = []
+                al = []
+                subject.cycle(2) { |x| sl << (x + 1) }
+                array.cycle(2) { |x| al << (x + 1) }
+
+                expect(sl).to eq al
+              end
+            end
+          end
+
+
+          MIMIC_METHODS.each do |m|
+            describe "method #{m}" do
+              it 'behaves like the method in Array' do
+                lr = subject.public_send m
+                ar = array.public_send m
+
+                if ar.equal? array
+                  expect(lr).to equal subject
+                else
+                  expect(lr).to eq ar
+                end
+
+                expect(subject._list).to eq array
+              end
+            end
+          end
+        end
       end
     end
 
-    class MyTestClassValMultImpl3
-      include Eapi::Common
+    describe 'list definition' do
+      class ListDefinitionTestKlass
+        include Eapi::List
 
-      property :something, type: MyMultipleEapi
-    end
+        elements required: true, type: String, unique: true
+      end
+
+      let(:definition) { {required: true, type: String, unique: true} }
 
-    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
-      [
-        [MyTestClassValMult, Array],
-        [MyTestClassValMultImpl, Set],
-        [MyTestClassValMultImpl2, MyMultiple],
-        [MyTestClassValMultImpl3, MyMultipleEapi],
-      ].each do |(eapi_class, type_class)|
-        eapi = eapi_class.new
-        res  = eapi.add_something :a
-        expect(res).to be eapi
-        expect(eapi.something.to_a).to eq [:a]
-        expect(eapi.something).to be_a_kind_of type_class
+      subject { ListDefinitionTestKlass.new }
+
+      context '.is_multiple?' do
+        it { expect(subject.class).to be_is_multiple }
       end
-    end
 
-    describe 'element validation' do
-      class MyTestClassValElements
-        include Eapi::Common
-        property :something, multiple: true, element_type: Hash
-        property :other, multiple: true, validate_element_with: ->(record, attr, value) do
-          record.errors.add(attr, "element must pass my custom validation") unless value == :valid_val
+      context '.definition_for_elements' do
+        it { expect(subject.class.definition_for_elements).to eq definition }
+      end
+
+      context 'required' do
+        it 'fails if empty' do
+          expect(subject).not_to be_valid
+          subject.add "Something"
+          expect(subject).to be_valid
         end
       end
 
-      describe 'using `type_element` property in definition' do
-        it 'will validate the type of all the elements in the list' do
-          eapi = MyTestClassValElements.new
-          eapi.add_something 1
-          expect(eapi).not_to be_valid
-          expect(eapi.errors.full_messages).to eq ["Something element must be a Hash"]
-          expect(eapi.errors.messages).to eq({something: ["element must be a Hash"]})
+      context 'type' do
+        it 'fails if any element is not of valid type' do
+          subject.add "Something"
+          subject.add :is
+          subject.add 1
+          expect(subject).not_to be_valid
+          subject.clear
+          subject.add "Just Strings"
+          subject.add "Many Strings"
+          expect(subject).to be_valid
+        end
+      end
 
-          eapi.something [{a: :b}]
-          expect(eapi).to be_valid
+      context 'unique' do
+        it 'fails if has any repeated elements' do
+          subject.add "Cramer"
+          subject.add "vs"
+          subject.add "Cramer"
+
+          expect(subject).not_to be_valid
+
+          msgs = {:_list => ["elements must be unique (repeated elements: {\"Cramer\"=>2})"]}
+          expect(subject.errors.messages).to eq msgs
+
+          subject.clear
+
+          subject.add "Cramer"
+          subject.add "vs"
+          subject.add "Other Guy"
+
+          expect(subject).to be_valid
         end
       end
 
-      describe 'using `validate_element_with` property in definition' do
+      context 'validate_with lambda' do
+        class MyTestClassListValElements
+          include Eapi::List
+          elements validate_with: ->(record, attr, value) do
+            record.errors.add(attr, "element must pass my custom validation") unless value == :valid_val
+          end
+        end
+
         it 'will run that custom validation for all the elements in the list' do
-          eapi = MyTestClassValElements.new
-          eapi.add_other 1
+          eapi = MyTestClassListValElements.new
+          eapi.add 1
           expect(eapi).not_to be_valid
-          expect(eapi.errors.full_messages).to eq ["Other element must pass my custom validation"]
-          expect(eapi.errors.messages).to eq({other: ["element must pass my custom validation"]})
+          expect(eapi.errors.full_messages).to eq [" list element must pass my custom validation"]
+          expect(eapi.errors.messages).to eq({_list: ["element must pass my custom validation"]})
 
-          eapi.other [:valid_val]
+          eapi.clear.add :valid_val
           expect(eapi).to be_valid
         end
       end
+
     end
   end
-
 end