the_array_comparator 0.1.1

data/spec/comparator/comparator_spec.rb

@@ -0,0 +1,198 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe Comparator do
+  it "let you register classes" do
+    comparator_instance = double('TestComparatorInstance')
+    comparator_instance.stub(:success?).and_return(true)
+
+    comparator_klass = double('TestComparatorClass')
+    comparator_klass.stub(:new).and_return(comparator_instance)
+
+    expect {
+      Comparator.register(:is_eqal_new, comparator_klass) 
+    }.to_not raise_error Exceptions::IncompatibleComparator
+  end
+
+  it "fails when registering a not suitable class" do
+    comparator_instance = double('TestComparatorInstance')
+    comparator_instance.stub(:successasdf?).and_return(true)
+
+    comparator_klass = double('TestComparatorClass')
+    comparator_klass.stub(:new).and_return(comparator_instance)
+    expect {
+      Comparator.register(:is_eqal_new, comparator_klass) 
+    }.to raise_error Exceptions::IncompatibleComparator
+  end
+  
+  it "let you add check to check for" do
+    testrun = Comparator.new
+    data = %w{ a b c d}
+    keyword = %w{ a }
+
+    expect {
+      testrun.add_check data , :contains_all , keyword
+    }.to_not raise_error
+  end
+
+  it "fails if an unknown check is given" do
+    testrun = Comparator.new
+    data = %w{ a b c d}
+    keyword = %w{ a }
+
+    expect {
+      testrun.add_check data , :contains_all_abc , keyword
+    }.to raise_error Exceptions::UnknownCheckType
+  end
+
+  it "let you register and use classes" do
+    comparator_instance = double('TestComparatorInstance')
+    comparator_instance.stub(:success?).and_return(true)
+
+    comparator_klass = double('TestComparatorClass')
+    comparator_klass.stub(:new).and_return(comparator_instance)
+
+    Comparator.register(:new_comp, comparator_klass) 
+
+    comparator = Comparator.new
+    comparator.add_check %w{a}, :new_comp , %{a}
+    result = comparator.success?
+
+    expect(result).to eq(true)
+  end
+
+  it "support some comparators by default" do
+    testrun = Comparator.new
+    data = %w{ a b c d}
+    keyword = %w{ a }
+
+    expect {
+      testrun.add_check data , :contains_all , keyword
+      testrun.add_check data , :contains_any , keyword
+      testrun.add_check data , :not_contains , keyword
+      testrun.add_check data , :contains_all_as_substring , keyword
+      testrun.add_check data , :contains_any_as_substring , keyword
+      testrun.add_check data , :not_contains_substring , keyword
+      testrun.add_check data , :is_equal , keyword
+      testrun.add_check data , :is_not_equal , keyword
+    }.to_not raise_error
+  end
+
+  it "is successfull if all subtests are successfull" do
+    comparator = Comparator.new
+    data = %w{ a b c d }
+    keyword_overlap = %w{ a b }
+    keyword_no_overlap = %w{ e }
+
+    comparator.add_check data , :contains_all , keyword_overlap
+    comparator.add_check data , :not_contains , keyword_no_overlap
+
+    result = comparator.success?
+    expect(result).to eq(true)
+  end
+  
+  it "fails if a least one subtest fails", :test => true do
+    comparator = Comparator.new
+    data = %w{ a b c d }
+    keyword_overlap = %w{ a }
+    keyword_no_overlap = %w{ e }
+
+    comparator.add_check data , :contains_all , keyword_overlap #should not fail
+    comparator.add_check data , :not_contains , keyword_overlap #should fail
+
+    result = comparator.success?
+    expect(result).to eq(false)
+  end
+
+  it "supports the addition of exceptions as well" do
+    comparator = Comparator.new
+    data = %w{ ab c d}
+    keyword_overlap = %w{ a }
+    exceptions = %w{ ab }
+
+    comparator.add_check data , :contains_any_as_substring , keyword_overlap
+    comparator.add_check data , :not_contains_substring , keyword_overlap, :exceptions => exceptions
+
+    result = comparator.success?
+    expect(result).to eq(true)
+  end
+
+  it "list all added check" do
+    comparator = Comparator.new
+    data = []
+    keywords = []
+
+    check = comparator.add_check data , :contains_any, keywords
+    list = comparator.list_checks.first
+
+    expect(list).to eq(check)
+  end
+
+  it "deletes the n-th check" do
+    comparator = Comparator.new
+    data = []
+    keywords = []
+
+    test_comps = []
+
+    test_comps << comparator.add_check(data , :contains_any, keywords)
+    comparator.add_check(data , :contains_any, keywords)
+    test_comps << comparator.add_check(data , :contains_any, keywords)
+    comparator.delete_check(1)
+
+    list = comparator.list_checks
+    expect(list).to eq(test_comps)
+  end
+
+  it "raises an error if a user tries to delete an unexisting check" do
+    comparator = Comparator.new
+
+    expect {
+      comparator.delete_last_check
+    }.to raise_error Exceptions::CheckDoesNotExist
+  end
+
+  it "deletes the last check" do
+    comparator = Comparator.new
+    data = []
+    keywords = []
+
+    test_comps = []
+
+    test_comps << comparator.add_check(data , :contains_any, keywords)
+    test_comps << comparator.add_check(data , :contains_any, keywords)
+    comparator.add_check(data , :contains_any, keywords)
+    comparator.delete_last_check
+
+    list = comparator.list_checks
+    expect(list).to eq(test_comps)
+  end
+
+  it "tells you the result of the check" do
+    comparator = Comparator.new
+    data = %w{ a b c d }
+    keyword_overlap = %w{ a b }
+    keyword_no_overlap = %w{ e }
+
+    comparator.add_check data , :contains_all , keyword_overlap
+    comparator.add_check data , :not_contains , keyword_no_overlap
+
+    comparator.success?
+    result = comparator.result
+    expect(result.of_checks).to eq(true)
+  end
+
+  it "tells you which check has failed and made the whole thing failed" do
+    comparator = Comparator.new
+    data = %w{ a b c d }
+    keyword_successfull = %w{ a b }
+    keyword_failed = %w{ e }
+
+    comparator.add_check data , :contains_all , keyword_successfull
+    c = comparator.add_check data , :contains_all , keyword_failed, tag: 'this is a failed sample'
+
+    comparator.success?
+    result = comparator.result
+    expect(result.failed_sample).to eq(c.sample)
+  end
+end

data/spec/comparator/contains_all_spec.rb

@@ -0,0 +1,52 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsAll do
+  let(:data) { %w{ a b c e} }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+  let(:multiple_keywords_with_one_no_overlap) { %w{ a b cd } }
+
+  it "fails if keywords are empty" do
+    sample = SampleDouble.new(data,[])
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if data is empty" do
+    sample = SampleDouble.new([],keywords_no_overlap)
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull if both keywords and data are empty" do
+    sample = SampleDouble.new([],[])
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "is successfull when there's a data overlap" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if not all keywords can be found within the data" do
+    sample = SampleDouble.new(data,multiple_keywords_with_one_no_overlap)
+    comparator = Strategies::ContainsAll.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's an exception" do
+    #not implemented since it's not neccessary
+    #just leave the unneed element out of the
+    #keyword array
+  end
+end

data/spec/comparator/contains_all_with_substring_search_spec.rb

@@ -0,0 +1,41 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsAllWithSubstringSearch do
+  let(:data) { %w{ ab c e} }
+  let(:exceptions) { %w{ b } }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+  let(:multiple_keywords_with_one_no_overlap) { %w{ a b cd } }
+
+  it "is successfull when there's a data overlap" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's an exception defined" do
+    sample = SampleDouble.new(data,keywords_overlap, exceptions)
+    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's an exception defined" do
+    sample = SampleDouble.new(data,multiple_keywords_with_one_no_overlap, exceptions)
+    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if not all keywords can be found within the data" do
+    sample = SampleDouble.new(data,multiple_keywords_with_one_no_overlap)
+    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+end

data/spec/comparator/contains_any_spec.rb

@@ -0,0 +1,45 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsAny do
+  let(:data) { %w{ a b c e} }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "fails if keywords are empty" do
+    sample = SampleDouble.new(data,[])
+    comparator = Strategies::ContainsAny.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if data is empty" do
+    sample = SampleDouble.new([],keywords_no_overlap)
+    comparator = Strategies::ContainsAny.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull if both keywords and data are empty" do
+    sample = SampleDouble.new([],[])
+    comparator = Strategies::ContainsAny.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "is successfull when there's a data overlap" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsAny.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsAny.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's an exception" do
+    #not implemented since it's not neccessary
+    #just leave the unneed element out of the
+    #keyword array
+  end
+end

data/spec/comparator/contains_any_with_substring_search_spec.rb

@@ -0,0 +1,35 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsAnyWithSubstringSearch do
+  let(:data) { %w{ ab c e} }
+  let(:exceptions) { %w{ b} }
+  let(:keywords_overlap) { %w{ a } }
+  let(:multiple_overlap) { %w{ a c d} }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "is successfull when there's a data overlap (at least one element)" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's an exception defined" do
+    sample = SampleDouble.new(data,keywords_overlap, exceptions)
+    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull, if there's a least one match (second match 'c' -> exception -> no match) " do
+    sample = SampleDouble.new(data,multiple_overlap, exceptions)
+    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+end

data/spec/comparator/contains_not_spec.rb

@@ -0,0 +1,45 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsNot do
+  let(:data) { %w{ a b c e} }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "is successfull if keywords are empty" do
+    sample = SampleDouble.new(data,[])
+    comparator = Strategies::ContainsNot.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "is successfull if data is empty" do
+    sample = SampleDouble.new([],keywords_no_overlap)
+    comparator = Strategies::ContainsNot.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "fails if both keywords and data are empty" do
+    sample = SampleDouble.new([],[])
+    comparator = Strategies::ContainsNot.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull if there's a data overlap" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsNot.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "doesn't find something if there's no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsNot.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's an exception" do
+    #not implemented since it's not neccessary
+    #just leave the unneed element out of the
+    #keyword array
+  end
+end

data/spec/comparator/contains_not_with_substring_search_spec.rb

@@ -0,0 +1,28 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::ContainsNotWithSubstringSearch do
+  let(:data) { %w{ ab c e } }
+  let(:exceptions) { %w{ a } }
+  let(:keywords_overlap) { %w{ ab } }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "is successfull when there's a no overlap" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "doesn't find something if there's an overlap" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull although there's an overlap, but an exception defined" do
+    sample = SampleDouble.new(data,keywords_overlap, exceptions)
+    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+end

data/spec/comparator/is_equal_spec.rb

@@ -0,0 +1,51 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::IsEqual do
+  let(:data) { %w{ a } }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "fails if keywords are empty" do
+    sample = SampleDouble.new(data,[])
+    comparator = Strategies::IsEqual.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if data is empty" do
+    sample = SampleDouble.new([],keywords_no_overlap)
+    comparator = Strategies::IsEqual.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull if both keywords and data are empty" do
+    sample = SampleDouble.new([],[])
+    comparator = Strategies::IsEqual.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "is successfull if data and keywords are equal" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::IsEqual.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "fails if data and keywords are different" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::IsEqual.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  #tested at this point for all classes
+  it "displays a warning if an exception is defined (is not supported by this strategy)" do
+    needed_msg = "Exceptions are not supported by this strategy.\n" 
+    sample = SampleDouble.new(data,keywords_no_overlap,%w{a})
+
+    msg = capture(:stderr) do
+      Strategies::IsEqual.new(sample)
+    end
+
+    expect(msg).to eq(needed_msg)
+  end
+end

data/spec/comparator/is_not_equal_spec.rb

@@ -0,0 +1,39 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::IsNotEqual do
+  let(:data) { %w{ a } }
+  let(:keywords_overlap) { %w{ a } }
+  let(:keywords_no_overlap) { %w{ d } }
+
+  it "is successfull if keywords are empty" do
+    sample = SampleDouble.new(data,[])
+    comparator = Strategies::IsNotEqual.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "is successfull if data is empty" do
+    sample = SampleDouble.new([],keywords_no_overlap)
+    comparator = Strategies::IsNotEqual.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+
+  it "fails if both keywords and data are empty" do
+    sample = SampleDouble.new([],[])
+    comparator = Strategies::IsNotEqual.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "fails if data and keywords are equal" do
+    sample = SampleDouble.new(data,keywords_overlap)
+    comparator = Strategies::IsNotEqual.new(sample)
+    expect(comparator.success?).to eq(false)
+  end
+
+  it "is successfull if data and keywords are different" do
+    sample = SampleDouble.new(data,keywords_no_overlap)
+    comparator = Strategies::IsNotEqual.new(sample)
+    expect(comparator.success?).to eq(true)
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Result do
+  sample_klass = Class.new do
+    attr_accessor :data, :keywords, :exceptions, :tag
+    
+    def initialize(data,keywords,exceptions,tag)
+      @data = data
+      @keywords = keywords
+      @exceptions = exceptions
+      @tag = tag
+    end
+  end
+
+  it "returns true if _no_ sample is defined" do
+    result = Result.new()
+    expect(result.of_checks).to eq(true)
+  end
+
+  it "returns false if sample is defined" do
+    data = %w{ data }
+    keywords = %w{ keywords }
+    exceptions = %w{ exceptions }
+    tag = 'this is a tag'
+    sample = sample_klass.new(data,keywords,exceptions,tag)
+
+    result = Result.new(sample)
+    expect(result.of_checks).to eq(false)
+  end
+
+end

data/spec/sample_spec.rb

@@ -0,0 +1,24 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe Sample do
+  it "takes nothing by default" do
+    expect {
+      Sample.new()
+    }.to_not raise_error
+  end
+
+  it "takes data, keywords, exceptions, tags" do
+      data = %w{ data }
+      keywords = %w{ keywords }
+      exceptions = %w{ exceptions }
+      tag = 'this is a tag'
+
+      sample = Sample.new(data, keywords, exceptions, tag)
+
+      expect(sample.data).to eq(data)
+      expect(sample.keywords).to eq(keywords)
+      expect(sample.exceptions).to eq(exceptions)
+      expect(sample.tag).to eq(tag)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+#encoding: utf-8
+
+$LOAD_PATH << File.expand_path('../lib' , File.dirname(__FILE__))
+
+unless ENV['TRAVIS_CI'] == 'true'
+  require 'pry'
+  require 'debugger'
+  require 'ap'
+  require 'ffaker'
+  require 'benchmark'
+end
+
+require 'stringio'
+require 'tempfile'
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/numeric/time'
+#require 'active_support/core_ext/kernel/reporting'
+
+unless ENV['TRAVIS_CI'] == 'true'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'the_array_comparator'
+require 'the_array_comparator/testing_helper/data_set'
+require 'the_array_comparator/testing_helper/test_data'
+require 'the_array_comparator/testing_helper'
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+#  c.filter_run_including :focus => true
+end
+
+include TheArrayComparator
+include TheArrayComparator::TestingHelper
+
+#ENV['PATH'] = '/bin'

data/spec/strategies_helper.rb

@@ -0,0 +1,11 @@
+class SampleDouble 
+
+  attr_accessor :data, :keywords, :exceptions,:tag
+
+  def initialize(data=[],keywords=[],exceptions=[],tag=nil)
+    @keywords = keywords
+    @data = data
+    @exceptions = exceptions
+    @tag = tag
+  end
+end

data/spec/testing_helper/testing_helper_spec.rb

@@ -0,0 +1,27 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe "#generate_testdata" do
+
+  it "spread the testdata when amount of data is lower than keywords" do
+    data = generate_testdata(keywords: %w{a b c d}, raw_data: %w{data1 data2})
+    expect(data[2]).to eq('a')
+  end
+
+  it "spread the testdata when amount of data is equal to the amount of the keywords" do
+    data = generate_testdata(keywords: %w{a b c d}, raw_data: %w{data1 data2 data3 data4})
+    expect(data[1]).to eq('a')
+    expect(data[2]).to eq('data2')
+  end
+
+  it "spread the testdata when amount of data is larger than keywords" do
+    data = generate_testdata(keywords: %w{a b c d}, raw_data: %w{data1 data2 data3 data4 data5})
+    expect(data[1]).to eq('a')
+  end
+
+  it "spread the testdata when amount of data is not a multiply of keywords (it cares for the rest)" do
+    data = generate_testdata(keywords: %w{a b c d}, raw_data: [ 'data' ] * 99 )
+    expect(data[2]).to eq('data')
+    expect(data[24]).to eq('a')
+  end
+end