metal_archives 2.2.0 → 3.1.1

data/spec/support/factory_girl.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.include FactoryGirl::Syntax::Methods
-end

data/spec/support/metal_archives.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'metal_archives'
-
-MetalArchives.configure do |c|
-  ## Application identity (required)
-  c.app_name = 'MetalArchivesGemTestSuite'
-  c.app_version = MetalArchives::VERSION
-  c.app_contact = 'user@example.com'
-
-  if ENV.has_key? 'TRAVIS'
-    ## Request throttling (optional, overrides defaults)
-    c.request_rate = 1
-    c.request_timeout = 3
-  end
-
-  ## Connect additional Faraday middleware
-  # c.middleware = [MyMiddleware, MyOtherMiddleware]
-
-  ## Custom cache size per object class (optional, overrides defaults)
-  # c.cache_size = 100
-
-  ## Metal Archives endpoint (optional, overrides default)
-  c.endpoint = ENV['MA_ENDPOINT'] if ENV['MA_ENDPOINT']
-
-  if ENV['MA_ENDPOINT']
-    puts "Using '#{ENV['MA_ENDPOINT']}' as MA endpoint"
-  end
-
-  ## Custom logger (optional)
-  c.logger = Logger.new STDOUT
-  c.logger.level = Logger::INFO
-end

data/spec/utils/collection_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe MetalArchives::Collection do
-  it 'iterates' do
-    l = lambda do
-      @i ||= 0
-
-      next [] if @i >= 100
-      items = (@i .. (@i + 9)).to_a
-      @i += 10
-
-      items
-    end
-
-    c = MetalArchives::Collection.new l
-
-    i = 0
-    c.each do |item|
-      expect(item).to eq i
-      i += 1
-    end
-  end
-
-  it 'returns' do
-    l = lambda do
-      @i ||= 0
-
-      raise StandardError if @i >= 100
-      items = (@i .. (@i + 9)).to_a
-      @i += 10
-
-      items
-    end
-
-    c = MetalArchives::Collection.new l
-
-    i = 0
-    c.each do |item|
-      break if i == 99
-      expect(item).to eq i
-      i += 1
-    end
-
-    expect(i).to eq 99
-  end
-
-  describe 'empty?' do
-    it 'is not empty' do
-      l = lambda do
-        @i ||= 0
-
-        next [] if @i >= 100
-        items = (@i .. (@i + 9)).to_a
-        @i += 10
-
-        items
-      end
-
-      c = MetalArchives::Collection.new l
-
-      i = 0
-
-      expect(c).not_to be_empty
-    end
-
-    it 'is empty' do
-      c = MetalArchives::Collection.new -> { [] }
-
-      expect(c).to be_empty
-    end
-  end
-end

data/spec/utils/lru_cache_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe MetalArchives::LRUCache do
-  let(:cache) { MetalArchives::LRUCache.new 3 }
-
-  it 'stores and retrieves objects' do
-    cache[:key] = 'MyString'
-
-    expect(cache[:key]).to eq 'MyString'
-  end
-
-  it 'clears cache' do
-    cache[:key] = 'MyString'
-    cache.clear
-
-    expect(cache[:key]).to be_nil
-  end
-
-  it 'peeks' do
-    expect(cache).not_to include :key
-
-    cache[:key] = 'MyString'
-
-    expect(cache).to include :key
-  end
-
-  it 'deletes' do
-    cache[:key] = 'MyString'
-
-    expect(cache).to include :key
-
-    cache.delete :key
-
-    expect(cache).not_to include :key
-  end
-
-  it 'implements LRU caching' do
-    cache[:a] = 'one'
-    cache[:b] = 'two'
-    cache[:c] = 'three'
-
-    expect(cache.instance_variable_get '@size').to eq 3
-
-    cache[:d] = 'four'
-
-    expect(cache.instance_variable_get '@size').to eq 3
-
-    expect(cache[:b]).to eq 'two'
-    expect(cache[:c]).to eq 'three'
-    expect(cache[:d]).to eq 'four'
-    expect(cache[:a]).to be_nil
-  end
-end

data/spec/utils/nil_date_spec.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe MetalArchives::NilDate do
-  let(:date) { build :nil_date }
-  let(:date_without_day) { build :nil_date, :day => nil }
-  let(:date_without_month) { build :nil_date, :month => nil }
-
-  it 'has the correct properties' do
-    expect(date).to respond_to :year
-    expect(date).to respond_to :year=
-    expect(date).to respond_to :year?
-
-    expect(date).to respond_to :month
-    expect(date).to respond_to :month=
-    expect(date).to respond_to :month?
-
-    expect(date).to respond_to :day
-    expect(date).to respond_to :day=
-    expect(date).to respond_to :day?
-  end
-
-  it 'returns the correct values' do
-    expect(date.year).not_to be_nil
-    expect(date.year).to be_an Integer
-    expect(date.year?).to be true
-
-    expect(date.month).not_to be_nil
-    expect(date.month).to be_an Integer
-    expect(date.month?).to be true
-
-    expect(date.day).not_to be_nil
-    expect(date.day).to be_an Integer
-    expect(date.day?).to be true
-  end
-
-  it 'does not require a day' do
-    expect(date_without_day.day).to be_nil
-    expect(date_without_day.day?).to be false
-  end
-
-  it 'does not require a month' do
-    expect(date_without_month.month).to be_nil
-    expect(date_without_month.month?).to be false
-  end
-
-  it 'returns a date' do
-    expect(date.date).to be_a Date
-    expect(date.date.year).to eq date.year
-    expect(date.date.month).to eq date.month
-    expect(date.date.day).to eq date.day
-  end
-
-  describe 'parsing' do
-    it 'parses empty dates' do
-      date = described_class.parse ''
-
-      expect(date.year?).to be false
-      expect(date.month?).to be false
-      expect(date.day?).to be false
-    end
-
-    it 'parses dates with year only' do
-      date = described_class.parse '2012'
-
-      expect(date.year?).to be true
-      expect(date.year).to eq 2012
-      expect(date.month?).to be false
-      expect(date.day?).to be false
-    end
-
-    it 'parses parses dates with year and month' do
-      date = described_class.parse '2012-10'
-
-      expect(date.year?).to be true
-      expect(date.year).to eq 2012
-      expect(date.month?).to be true
-      expect(date.month).to eq 10
-      expect(date.day?).to be false
-    end
-
-    it 'parses dates with leading zeroes' do
-      date = described_class.parse '2017-01-00'
-
-      expect(date.year).to eq 2017
-      expect(date.month).to eq 1
-      expect(date.day).to eq nil
-    end
-
-    it 'parses full dates' do
-      date = described_class.parse '2012-10-02'
-
-      expect(date.year?).to be true
-      expect(date.year).to eq 2012
-      expect(date.month?).to be true
-      expect(date.month).to eq 10
-      expect(date.day?).to be true
-      expect(date.day).to eq 2
-    end
-
-    it 'does not parse on invalid dates' do
-      expect(-> { described_class.parse 'October 2nd, 2012' }).to raise_error MetalArchives::Errors::ArgumentError
-      expect(-> { described_class.parse 'a-b-c' }).to raise_error MetalArchives::Errors::ArgumentError
-      expect(-> { described_class.parse "This isn't a date" }).to raise_error MetalArchives::Errors::ArgumentError
-    end
-  end
-
-  it 'includes comparable' do
-    date1 = described_class.new 2015, 01, 01
-    date2 = described_class.new 2015, 01, 02
-    date3 = described_class.new 2015, 02, 01
-    date4 = described_class.new 2016, 01, 02
-    date5 = described_class.new 2015, 01, 01
-    date6 = described_class.new 2014, 12, 31
-    date7 = described_class.new 2015, 01, nil
-    date8 = described_class.new 2015, 01, nil
-    date9 = described_class.new 2015, 02, nil
-    date10 = described_class.new 2015, nil, nil
-    date11 = described_class.new 2016, nil, nil
-
-    expect(date1 <=> date2).to eq -1
-    expect(date2 <=> date1).to eq 1
-    expect(date1 <=> date3).to eq -1
-    expect(date3 <=> date1).to eq 1
-    expect(date1 <=> date4).to eq -1
-    expect(date4 <=> date1).to eq 1
-    expect(date1 <=> date5).to eq 0
-    expect(date5 <=> date1).to eq 0
-    expect(date6 <=> date1).to eq -1
-    expect(date1 <=> date6).to eq 1
-
-    expect(date1 <=> date7).to eq nil
-    expect(date7 <=> date1).to eq nil
-    expect(date1 <=> date9).to eq nil
-    expect(date9 <=> date1).to eq nil
-    expect(date7 <=> date8).to eq 0
-    expect(date8 <=> date7).to eq 0
-    expect(date7 <=> date9).to eq -1
-    expect(date9 <=> date7).to eq 1
-    expect(date7 <=> date10).to eq nil
-    expect(date10 <=> date7).to eq nil
-    expect(date10 <=> date11).to eq -1
-    expect(date11 <=> date10).to eq 1
-  end
-
-  it 'prints to string' do
-    date1 = described_class.new 2015, nil, nil
-    date2 = described_class.new 2015, 01, nil
-    date3 = described_class.new 2015, 01, 01
-    date4 = described_class.new 2015, nil, 01
-
-    expect(date1.to_s).to eq '2015-00-00'
-    expect(date2.to_s).to eq '2015-01-00'
-    expect(date3.to_s).to eq '2015-01-01'
-    expect(date4.to_s).to eq '2015-00-01'
-  end
-end

data/spec/utils/range_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe MetalArchives::Range do
-  let(:range) { build :range }
-  let(:begin_range) { build :range, :end => nil }
-  let(:end_range) { build :range, :begin => nil }
-
-  it 'has the correct properties' do
-    expect(range).to respond_to :begin
-    expect(range).to respond_to :begin=
-    expect(range).to respond_to :begin?
-
-    expect(range).to respond_to :end
-    expect(range).to respond_to :end=
-    expect(range).to respond_to :end?
-  end
-
-  it 'returns the correct values' do
-    expect(range.begin).not_to be_nil
-    expect(range.begin).to be_a Date
-    expect(range.begin?).to be true
-
-    expect(range.end).not_to be_nil
-    expect(range.end).to be_a Date
-    expect(range.end?).to be true
-  end
-
-  it 'does not require an end date' do
-    expect(begin_range.end).to be_nil
-    expect(begin_range.end?).to be false
-  end
-
-  it 'does not require a begin date' do
-    expect(end_range.begin).to be_nil
-    expect(end_range.begin?).to be false
-  end
-
-  it 'implements comparable' do
-    range1 = described_class.new 1, 3
-    range1a = described_class.new 1, 3
-    range2 = described_class.new nil, 3
-    range2a = described_class.new nil, 3
-    range3 = described_class.new 1, nil
-    range3a = described_class.new 1, nil
-
-    range4 = described_class.new 1, 4
-    range5 = described_class.new 0, 3
-
-    expect(range1 <=> range1a).to eq 0
-    expect(range2 <=> range2a).to eq 0
-    expect(range3 <=> range3a).to eq 0
-
-    expect(range1 <=> range2).to be_nil
-    expect(range2 <=> range3).to be_nil
-    expect(range3 <=> range1).to be_nil
-
-    expect(range1 <=> range4).to eq -1
-    expect(range1 <=> range5).to eq -1
-    expect(range4 <=> range1).to eq 1
-    expect(range5 <=> range1).to eq 1
-  end
-end