Създаване на хеш чрез map

Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Решение на Четвърта задача - Unit тестване от Петко Митков

Обратно към всички решения

Към профила на Петко Митков

Резултати

  • 6 точки от тестове
  • 0 бонус точки
  • 6 точки общо
  • 18 успешни тест(а)
  • 1 неуспешни тест(а)

Код

RSpec.describe 'Version' do
describe '#initialize' do
it 'does not raise error with empty string' do
expect { Version.new '' }.to_not raise_error
end
it 'does not raise error with valid version' do
expect { Version.new '1.2.3' }.to_not raise_error
end
it 'raises error with invalid version' do
version = '1..2'
expect { Version.new version }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
it 'does not raise error with no arguments' do
expect { Version.new }.to_not raise_error
end
it 'does not raise error with version instance' do
expect { Version.new Version.new }.to_not raise_error
end
end
describe '#<' do
context 'when versions have equal length' do
it 'is true for smaller version' do
expect(Version.new('1.2')).to be < Version.new('1.3')
end
it 'is false for larger version' do
expect(Version.new('1.3')).to_not be < Version.new('1.2')
end
it 'is false for equal versions' do
expect(Version.new('1.2')).to_not be < Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for smaller version' do
expect(Version.new('1.3')).to be < Version.new('1.3.1')
end
it 'is false for larger version' do
expect(Version.new('1.3.1')).to_not be < Version.new('1.3')
end
it 'is false for equal versions' do
expect(Version.new('1.3')).to_not be < Version.new('1.3.0')
end
end
end
describe '#>' do
context 'when versions have equal length' do
it 'is true for larger version' do
expect(Version.new('1.3')).to be > Version.new('1.2')
end
it 'is false for smaller version' do
expect(Version.new('1.2')).to_not be > Version.new('1.3')
end
it 'is false for equal versions' do
expect(Version.new('1.2')).to_not be > Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for larger version' do
expect(Version.new('1.3.1')).to be > Version.new('1.3')
end
it 'is false for smaller version' do
expect(Version.new('1.3')).to_not be > Version.new('1.3.1')
end
it 'is false for equal versions' do
expect(Version.new('1.3')).to_not be > Version.new('1.3.0')
end
end
end
describe '#<=' do
context 'when versions have equal length' do
it 'is true for smaller version' do
expect(Version.new('1.2')).to be <= Version.new('1.3')
end
it 'is false for larger version' do
expect(Version.new('1.3')).to_not be <= Version.new('1.2')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be <= Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for smaller version' do
expect(Version.new('1.3')).to be <= Version.new('1.3.1')
end
it 'is false for larger version' do
expect(Version.new('1.3.1')).to_not be <= Version.new('1.3')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be <= Version.new('1.3.0')
end
end
end
describe '#>=' do
context 'when versions have equal length' do
it 'is true for larger version' do
expect(Version.new('1.3')).to be >= Version.new('1.2')
end
it 'is false for smaller version' do
expect(Version.new('1.2')).to_not be >= Version.new('1.3')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be >= Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for larger version' do
expect(Version.new('1.3.1')).to be >= Version.new('1.3')
end
it 'is false for smaller version' do
expect(Version.new('1.3')).to_not be >= Version.new('1.3.1')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be >= Version.new('1.3.0')
end
end
end
describe '#==' do
context 'when versions have equal length' do
it 'is false for non-equal versions' do
expect(Version.new('1.2')).to_not be == Version.new('1.3')
expect(Version.new('1.3')).to_not be == Version.new('1.2')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be == Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is false for non-equal versions' do
expect(Version.new('1.3.1')).to_not be == Version.new('1.3')
expect(Version.new('1.3')).to_not be == Version.new('1.3.1')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be == Version.new('1.3.0')
end
end
end
describe '#<=>' do
context 'when versions have equal length' do
it 'compares smaller with larger version' do
expect(Version.new('1.2') <=> Version.new('1.3')).to eq -1
end
it 'compares larger with smaller version' do
expect(Version.new('1.3') <=> Version.new('1.2')).to eq 1
end
it 'compares equal versions' do
version = Version.new('1.2')
expect(version <=> Version.new('1.2')).to eq 0
end
end
context 'when versions have different length' do
it 'compares smaller with larger version' do
expect(Version.new('1.3') <=> Version.new('1.3.1')).to eq -1
end
it 'compares larger with smaller version' do
expect(Version.new('1.3.1') <=> Version.new('1.3')).to eq 1
end
it 'compares equal versions' do
expect(Version.new('1.3') <=> Version.new('1.3.0')).to eq 0
end
end
end
describe '#to_s' do
context 'when version does not have ending zeros' do
it 'shows basic version' do
expect(Version.new('1.3').to_s).to eq '1.3'
end
it 'shows the empty version' do
expect(Version.new('').to_s).to eq ''
end
end
context 'when version has ending zeros' do
it 'shows basic version' do
expect(Version.new('1.3.0').to_s).to eq '1.3'
end
it 'shows the 0 version' do
expect(Version.new('0').to_s).to eq ''
end
end
end
describe '#components' do
context 'when no optional argument is given' do
it 'gets simple version' do
expect(Version.new('1.2').components).to eq([1, 2])
end
it 'gets version ending with zero' do
expect(Version.new('1.2.0').components).to eq([1, 2])
end
it 'does not modify the version' do
version = Version.new('1.2')
version.components.push -1
expect(version.components).to eq([1, 2])
end
end
context 'when optional argument is given' do
it 'gets simple version with fewer elements' do
expect(Version.new('1.2.3').components(5)).to eq([1, 2, 3, 0, 0])
end
it 'gets simple version with more elements' do
expect(Version.new('1.2.3').components(2)).to eq([1, 2])
end
it 'gets simple version with equal amount of elements' do
expect(Version.new('1.2.3').components(3)).to eq([1, 2, 3])
end
end
end
describe '#Version::Range' do
describe '#initialize' do
it 'does not raise error with valid versions' do
expect { Version::Range.new('1.2.3', '1.2.4') }.to_not raise_error
end
it 'raises error with invalid versions' do
version = '..3'
expect { Version::Range.new(version, '1.2.4') }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
end
describe '#include?' do
it 'returns true for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.5')).to be true
end
it 'returns false for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.2')).to be false
end
it 'returns false when version is equal to last version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.9')).to be false
end
it 'returns true when version is equal to first version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.3')).to be true
end
end
describe '#to_a' do
it 'shows for simple range' do
range = Version::Range.new('1.2.6', '1.3.1')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2.6', '1.2.7',
'1.2.8', '1.2.9', '1.3'
]
)
end
it 'shows for range with shorter version' do
range = Version::Range.new('1.2', '1.3')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2', '1.2.1', '1.2.2',
'1.2.3', '1.2.4', '1.2.5',
'1.2.6', '1.2.7', '1.2.8', '1.2.9'
]
)
end
it 'shows for range with no versions' do
range = Version::Range.new('1.2', '1.2')
expect(range.to_a.map(&:to_s)).to eq([])
end
end
end
end

Лог от изпълнението

.............F.....

Failures:

  1) spec Version::Range tests constructing ranges with versions
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
           VALID_VERSION_REGEXP = /\A\z|\A[0-9]+(\.[0-9]+)*\z/
         
           include Comparable
         
           def initialize(version = '')
             unless VALID_VERSION_REGEXP.match(version.to_s)
               raise ArgumentError, "Invalid version string '#{version}'"
             end
         
             @components = version.to_s
               .split('.')
               .map(&:to_i)
               .reverse
               .drop_while(&:zero?)
               .reverse
           end
         
           def <=>(other)
             @components <=> Version.new(other).internal_components
           end
         
           def internal_components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def components(positions = 0)
             padding_size = positions - @components.size
         
             if padding_size > 0
               @components + [0] * padding_size
             elsif positions != 0
               @components.take(positions)
             else
               @components.dup
             end
           end
         
           def to_s
             @components.join('.')
           end
         
           class Range
             include Enumerable
         
             def initialize(start_version, end_version)
               raise 'error' if start_version.is_a?(Version) || end_version.is_a?(Version)
             
               @start_version = Version.new(start_version)
               @end_version   = Version.new(end_version)
             end
         
             def include?(version)
               (@start_version <=> version) < 1 && (@end_version <=> version) == 1
             end
         
             def each
               current_version = @start_version
         
               while (current_version <=> @end_version) == -1
                 yield current_version
         
                 current_version = increment_version(current_version)
               end
             end
         
             private
         
             def increment_version(version)
               components = version.internal_components(3)
         
               components[2] += 1
         
               components.to_enum.with_index.reverse_each do |_, index|
                 component = components[index]
         
                 if component >= 10 && components[index - 1]
                   components[index]      = 0
                   components[index - 1] += 1
                 end
               end
         
               Version.new(components.join('.'))
             end
           end
         end
     # /tmp/d20161119-19072-1qghg9q/spec.rb:492:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (2 levels) in <top (required)>'

Finished in 19.54 seconds
19 examples, 1 failure

Failed examples:

rspec /tmp/d20161119-19072-1qghg9q/spec.rb:482 # spec Version::Range tests constructing ranges with versions

История (4 версии и 8 коментара)

Петко обнови решението на 17.11.2016 00:34 (преди около 9 години)

+RSpec.describe 'Version' do
+ describe '#initialize' do
+ it 'does not raise error with empty string' do
+ expect { Version.new '' }.to_not raise_error
+ end
+
+ it 'does not raise error with valid version' do
+ expect { Version.new '1.2.3' }.to_not raise_error
+ end
+
+ it 'raises error with invalid version' do
+ version = '1..2'
+ expect { Version.new version }.to raise_error(
+ ArgumentError,
+ "Invalid version string '#{version}'"
+ )
+ end
+
+ it 'does not raise error with no arguments' do
+ expect { Version.new }.to_not raise_error
+ end
+
+ it 'does not raise error with version instance' do
+ expect { Version.new Version.new }.to_not raise_error
+ end
+ end
+
+ describe '#<' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares versions and returns true' do
+ expect(first).to be < second
+ end
+
+ it 'compares versions and returns false' do
+ expect(second).to_not be < first
+ end
+
+ it 'compares equal versions and returns false' do
+ expect(first).to_not be < first
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares versions and returns true' do
+ expect(first).to be < second
+ end
+
+ it 'compares versions and returns false' do
+ expect(second).to_not be < first
+ end
+
+ it 'compares equal versions and returns false' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first).to_not be < first_with_zero
+ end
+ end
+ end
+
+ describe '#>' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares versions and returns true' do
+ expect(second).to be > first
+ end
+
+ it 'compares versions and returns false' do
+ expect(first).to_not be > second
+ end
+
+ it 'compares equal versions and returns false' do
+ expect(first).to_not be > first
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares versions and returns true' do
+ expect(second).to be > first
+ end
+
+ it 'compares versions and returns false' do
+ expect(first).to_not be > second
+ end
+
+ it 'compares equal versions and returns false' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first).to_not be > first_with_zero
+ end
+ end
+ end
+
+ describe '#<=' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares versions and returns true' do
+ expect(first).to be <= second
+ end
+
+ it 'compares versions and returns false' do
+ expect(second).to_not be <= first
+ end
+
+ it 'compares equal versions and returns true' do
+ expect(first).to be <= first
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares versions and returns true' do
+ expect(first).to be <= second
+ end
+
+ it 'compares versions and returns false' do
+ expect(second).to_not be <= first
+ end
+
+ it 'compares equal versions and returns true' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first).to be <= first_with_zero
+ end
+ end
+ end
+
+ describe '#>=' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares versions and returns true' do
+ expect(second).to be >= first
+ end
+
+ it 'compares versions and returns false' do
+ expect(first).to_not be >= second
+ end
+
+ it 'compares equal versions and returns true' do
+ expect(first).to be >= first
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares versions and returns true' do
+ expect(second).to be >= first
+ end
+
+ it 'compares versions and returns false' do
+ expect(first).to_not be >= second
+ end
+
+ it 'compares equal versions and returns true' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first).to be >= first_with_zero
+ end
+ end
+ end
+
+ describe '#==' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares versions and returns false' do
+ expect(second).to_not be == first
+ end
+
+ it 'compares versions and returns false' do
+ expect(first).to_not be == second
+ end
+
+ it 'compares equal versions and returns true' do
+ expect(first).to be == first
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares versions and returns true' do
+ expect(second).to_not be == first
+ end
+
+ it 'compares versions and returns true' do
+ expect(first).to_not be == second
+ end
+
+ it 'compares equal versions and returns true' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first).to be == first_with_zero
+ end
+ end
+ end
+
+ describe '#<=>' do
+ context 'when versions have equal length' do
+ let(:first) { Version.new '1.2' }
+ let(:second) { Version.new '1.3' }
+
+ it 'compares different versions' do
+ expect(first <=> second).to eq -1
+ end
+
+ it 'compares different versions' do
+ expect(second <=> first).to eq 1
+ end
+
+ it 'compares equal versions' do
+ equal_to_first = Version.new('1.2')
+ expect(first <=> equal_to_first).to eq 0
+ end
+ end
+
+ context 'when versions have different length' do
+ let(:first) { Version.new '1.3' }
+ let(:second) { Version.new '1.3.1' }
+
+ it 'compares different versions' do
+ expect(first <=> second).to eq -1
+ end
+
+ it 'compares different versions' do
+ expect(second <=> first).to eq 1
+ end
+
+ it 'compares equal versions' do
+ first_with_zero = Version.new '1.3.0'
+ expect(first <=> first_with_zero).to eq 0
+ end
+ end
+ end
+
+ describe '#to_s' do
+ context 'when version has ending zeros' do
+ it 'shows basic version' do
+ version = '1.3'
+ expect(Version.new(version).to_s).to eq version
+ end
+
+ it 'shows the empty version' do
+ version = ''
+ expect(Version.new(version).to_s).to eq version
+ end
+ end
+
+ context 'when version does not have ending zeros' do
+ it 'shows basic version' do
+ version = '1.3.0'
+ expect(Version.new(version).to_s).to eq '1.3'
+ end
+
+ it 'shows the 0 version' do
+ version = '0'
+ expect(Version.new(version).to_s).to eq ''
+ end
+ end
+ end
+
+ describe '#components' do
+ context 'when no optional argument is given' do
+ it 'gets simple version' do
+ version = '1.2'
+ expect(Version.new(version).components).to eq([1, 2])
+ end
+
+ it 'gets version ending with zero' do
+ version = '1.2.0'
+ expect(Version.new(version).components).to eq([1, 2])
+ end
+
+ it 'does not modify the version' do
+ version = Version.new('1.2')
+ component = version.components
+ new_component = component.dup
+ component.push 10
+ expect(version.components).to eq(new_component)
+ end
+ end
+
+ context 'when optional argument is given' do
+ it 'gets simple version with fewer elements' do
+ version = '1.2.3'
+ expect(Version.new(version).components(5)).to eq([1, 2, 3, 0, 0])
+ end
+
+ it 'gets simple version with more elements' do
+ version = '1.2.3'
+ expect(Version.new(version).components(2)).to eq([1, 2])
+ end
+
+ it 'gets simple version with equal amount of elements' do
+ version = '1.2.3'
+ expect(Version.new(version).components(3)).to eq([1, 2, 3])
+ end
+ end
+ end
+
+ describe '#Version::Range' do
+ describe '#initialize' do
+ it 'does not raise error with valid versions' do
+ expect { Version::Range.new('1.2.3', '1.2.4') }.to_not raise_error
+ end
+
+ it 'raises error with invalid versions' do
+ version = '..3'
+ expect { Version::Range.new(version, '1.2.4') }.to raise_error(
+ ArgumentError,
+ "Invalid version string '#{version}'"
+ )
+ end
+ end
+
+ describe '#include?' do
+ it 'returns true for simple version' do
+ range = Version::Range.new('1.2.3', '1.2.9')
+ expect(range.include?('1.2.5')).to be true
+ end
+
+ it 'returns false for simple version' do
+ range = Version::Range.new('1.2.3', '1.2.9')
+ expect(range.include?('1.2.2')).to be false
+ end
+
+ it 'returns false when version is equal to last version in range' do
+ range = Version::Range.new('1.2.3', '1.2.9')
+ expect(range.include?('1.2.9')).to be false
+ end
+
+ it 'returns true when version is equal to first version in range' do
+ range = Version::Range.new('1.2.3', '1.2.9')
+ expect(range.include?('1.2.3')).to be true
+ end
+ end
+
+ describe '#to_a' do
+ it 'shows for simple range' do
+ range = Version::Range.new('1.2.6', '1.3.1')
+ expect(range.to_a.map(&:to_s)).to eq(
+ [
+ '1.2.6', '1.2.7',
+ '1.2.8', '1.2.9', '1.3'
+ ]
+ )
+ end
+
+ it 'shows for range with shorter version' do
+ range = Version::Range.new('1.2', '1.3')
+ expect(range.to_a.map(&:to_s)).to eq(
+ [
+ '1.2', '1.2.1', '1.2.2',
+ '1.2.3', '1.2.4', '1.2.5',
+ '1.2.6', '1.2.7', '1.2.8', '1.2.9'
+ ]
+ )
+ end
+
+ it 'shows for range with no versions' do
+ range = Version::Range.new('1.2', '1.2')
+ expect(range.to_a.map(&:to_s)).to eq([])
+ end
+ end
+ end
+end

Петко обнови решението на 17.11.2016 01:24 (преди около 9 години)

RSpec.describe 'Version' do
describe '#initialize' do
it 'does not raise error with empty string' do
expect { Version.new '' }.to_not raise_error
end
it 'does not raise error with valid version' do
expect { Version.new '1.2.3' }.to_not raise_error
end
it 'raises error with invalid version' do
version = '1..2'
expect { Version.new version }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
it 'does not raise error with no arguments' do
expect { Version.new }.to_not raise_error
end
it 'does not raise error with version instance' do
expect { Version.new Version.new }.to_not raise_error
end
end
describe '#<' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares versions and returns true' do

Имаш два варианта тук:

  1. Правиш описанията по-добри от it compares versions
  2. Махаш context-а и слагаш трите примера в един it, и го кръщаваш it 'compares versions with equal length'

В момента ако четеш лога ще видиш "compares versions and returns true" и "compares versions and returns false", които си противоречат.

Георги Ангелов
expect(first).to be < second
end
it 'compares versions and returns false' do
expect(second).to_not be < first
end
it 'compares equal versions and returns false' do
expect(first).to_not be < first
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares versions and returns true' do
expect(first).to be < second
end
it 'compares versions and returns false' do
expect(second).to_not be < first
end
it 'compares equal versions and returns false' do
first_with_zero = Version.new '1.3.0'
expect(first).to_not be < first_with_zero
end
end
end
describe '#>' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares versions and returns true' do
expect(second).to be > first
end
it 'compares versions and returns false' do
expect(first).to_not be > second
end
it 'compares equal versions and returns false' do
expect(first).to_not be > first
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares versions and returns true' do
expect(second).to be > first
end
it 'compares versions and returns false' do
expect(first).to_not be > second
end
it 'compares equal versions and returns false' do
first_with_zero = Version.new '1.3.0'
expect(first).to_not be > first_with_zero
end
end
end
describe '#<=' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares versions and returns true' do
expect(first).to be <= second
end
it 'compares versions and returns false' do
expect(second).to_not be <= first
end
it 'compares equal versions and returns true' do
expect(first).to be <= first
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares versions and returns true' do
expect(first).to be <= second
end
it 'compares versions and returns false' do
expect(second).to_not be <= first
end
it 'compares equal versions and returns true' do
first_with_zero = Version.new '1.3.0'
expect(first).to be <= first_with_zero
end
end
end
describe '#>=' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares versions and returns true' do
expect(second).to be >= first
end
it 'compares versions and returns false' do
expect(first).to_not be >= second
end
it 'compares equal versions and returns true' do
expect(first).to be >= first
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares versions and returns true' do
expect(second).to be >= first
end
it 'compares versions and returns false' do
expect(first).to_not be >= second
end
it 'compares equal versions and returns true' do
first_with_zero = Version.new '1.3.0'
expect(first).to be >= first_with_zero
end
end
end
describe '#==' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares versions and returns false' do
expect(second).to_not be == first
end
it 'compares versions and returns false' do
expect(first).to_not be == second
end
it 'compares equal versions and returns true' do
expect(first).to be == first
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares versions and returns true' do
expect(second).to_not be == first
end
it 'compares versions and returns true' do
expect(first).to_not be == second
end
it 'compares equal versions and returns true' do
first_with_zero = Version.new '1.3.0'
expect(first).to be == first_with_zero
end
end
end
describe '#<=>' do
context 'when versions have equal length' do
let(:first) { Version.new '1.2' }
let(:second) { Version.new '1.3' }
it 'compares different versions' do
expect(first <=> second).to eq -1
end
it 'compares different versions' do
expect(second <=> first).to eq 1
end
it 'compares equal versions' do
equal_to_first = Version.new('1.2')
expect(first <=> equal_to_first).to eq 0
end
end
context 'when versions have different length' do
let(:first) { Version.new '1.3' }
let(:second) { Version.new '1.3.1' }
it 'compares different versions' do
expect(first <=> second).to eq -1
end
it 'compares different versions' do
expect(second <=> first).to eq 1
end
it 'compares equal versions' do
first_with_zero = Version.new '1.3.0'
expect(first <=> first_with_zero).to eq 0
end
end
end
describe '#to_s' do
- context 'when version has ending zeros' do
+ context 'when version does not have ending zeros' do
it 'shows basic version' do
version = '1.3'
expect(Version.new(version).to_s).to eq version
end
it 'shows the empty version' do
version = ''
expect(Version.new(version).to_s).to eq version
end
end
- context 'when version does not have ending zeros' do
+ context 'when version has ending zeros' do
it 'shows basic version' do
version = '1.3.0'
expect(Version.new(version).to_s).to eq '1.3'
end
it 'shows the 0 version' do
version = '0'
expect(Version.new(version).to_s).to eq ''
end
end
end
describe '#components' do
context 'when no optional argument is given' do
it 'gets simple version' do
version = '1.2'
expect(Version.new(version).components).to eq([1, 2])
end
it 'gets version ending with zero' do
version = '1.2.0'
expect(Version.new(version).components).to eq([1, 2])
end
it 'does not modify the version' do
version = Version.new('1.2')
component = version.components
new_component = component.dup
component.push 10
expect(version.components).to eq(new_component)

Ами този тест го направих за да проверя дали version.components.object_id != version.components.object_id, което се очаква, но по много глупав начин. Иначе, ако метода променя вътрешно състоянието и връща копие, то теста ще фейлне, защото не проверява за този случай.

Петко Митков

Първият път като го четох съм го разбрал погрешно. Обърка ме dup-а, който правиш. Затова тестовете трябва да са много очевидни. Сравни твоето решение с това:

version = Version.new('1.2')
version.components.push 10

expect(version.components).to eq [1, 2]
Георги Ангелов
end
end
context 'when optional argument is given' do
it 'gets simple version with fewer elements' do
version = '1.2.3'
expect(Version.new(version).components(5)).to eq([1, 2, 3, 0, 0])
end
it 'gets simple version with more elements' do
version = '1.2.3'
expect(Version.new(version).components(2)).to eq([1, 2])
end
it 'gets simple version with equal amount of elements' do
version = '1.2.3'
expect(Version.new(version).components(3)).to eq([1, 2, 3])
end
end
end
describe '#Version::Range' do
describe '#initialize' do
it 'does not raise error with valid versions' do
expect { Version::Range.new('1.2.3', '1.2.4') }.to_not raise_error
end
it 'raises error with invalid versions' do
version = '..3'
expect { Version::Range.new(version, '1.2.4') }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
end
describe '#include?' do
it 'returns true for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.5')).to be true
end
it 'returns false for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.2')).to be false
end
it 'returns false when version is equal to last version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.9')).to be false
end
it 'returns true when version is equal to first version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.3')).to be true
end
end
describe '#to_a' do
it 'shows for simple range' do
range = Version::Range.new('1.2.6', '1.3.1')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2.6', '1.2.7',
'1.2.8', '1.2.9', '1.3'
]
)
end
it 'shows for range with shorter version' do
range = Version::Range.new('1.2', '1.3')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2', '1.2.1', '1.2.2',
'1.2.3', '1.2.4', '1.2.5',
'1.2.6', '1.2.7', '1.2.8', '1.2.9'
]
)
end
it 'shows for range with no versions' do
range = Version::Range.new('1.2', '1.2')
expect(range.to_a.map(&:to_s)).to eq([])
end
end
end
end

Петко обнови решението на 18.11.2016 21:30 (преди около 9 години)

RSpec.describe 'Version' do
describe '#initialize' do
it 'does not raise error with empty string' do
expect { Version.new '' }.to_not raise_error
end
it 'does not raise error with valid version' do
expect { Version.new '1.2.3' }.to_not raise_error
end
it 'raises error with invalid version' do
version = '1..2'
expect { Version.new version }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
it 'does not raise error with no arguments' do
expect { Version.new }.to_not raise_error
end
it 'does not raise error with version instance' do
expect { Version.new Version.new }.to_not raise_error
end
end
describe '#<' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares versions and returns true' do
- expect(first).to be < second
+ it 'is true for smaller version' do
+ expect(Version.new('1.2')).to be < Version.new('1.3')
end
- it 'compares versions and returns false' do
- expect(second).to_not be < first
+ it 'is false for larger version' do
+ expect(Version.new('1.3')).to_not be < Version.new('1.2')
end
- it 'compares equal versions and returns false' do
- expect(first).to_not be < first
+ it 'is false for equal versions' do
+ expect(Version.new('1.2')).to_not be < Version.new('1.2')
end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
-
- it 'compares versions and returns true' do
- expect(first).to be < second
+ it 'is true for smaller version' do
+ expect(Version.new('1.3')).to be < Version.new('1.3.1')
end
- it 'compares versions and returns false' do
- expect(second).to_not be < first
+ it 'is false for larger version' do
+ expect(Version.new('1.3.1')).to_not be < Version.new('1.3')
end
- it 'compares equal versions and returns false' do
- first_with_zero = Version.new '1.3.0'
- expect(first).to_not be < first_with_zero
+ it 'is false for equal versions' do
+ expect(Version.new('1.3')).to_not be < Version.new('1.3.0')
end
end
end
describe '#>' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares versions and returns true' do
- expect(second).to be > first
+ it 'is true for larger version' do
+ expect(Version.new('1.3')).to be > Version.new('1.2')
end
- it 'compares versions and returns false' do
- expect(first).to_not be > second
+ it 'is false for smaller version' do
+ expect(Version.new('1.2')).to_not be > Version.new('1.3')
end
- it 'compares equal versions and returns false' do
- expect(first).to_not be > first
+ it 'is false for equal versions' do
+ expect(Version.new('1.2')).to_not be > Version.new('1.2')
end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
-
- it 'compares versions and returns true' do
- expect(second).to be > first
+ it 'is true for larger version' do
+ expect(Version.new('1.3.1')).to be > Version.new('1.3')
end
- it 'compares versions and returns false' do
- expect(first).to_not be > second
+ it 'is false for smaller version' do
+ expect(Version.new('1.3')).to_not be > Version.new('1.3.1')
end
- it 'compares equal versions and returns false' do
- first_with_zero = Version.new '1.3.0'
- expect(first).to_not be > first_with_zero
+ it 'is false for equal versions' do
+ expect(Version.new('1.3')).to_not be > Version.new('1.3.0')
end
end
end
describe '#<=' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares versions and returns true' do
- expect(first).to be <= second
+ it 'is true for smaller version' do
+ expect(Version.new('1.2')).to be <= Version.new('1.3')
end
- it 'compares versions and returns false' do
- expect(second).to_not be <= first
+ it 'is false for larger version' do
+ expect(Version.new('1.3')).to_not be <= Version.new('1.2')
end
- it 'compares equal versions and returns true' do
- expect(first).to be <= first
+ it 'is true for equal versions' do
+ expect(Version.new('1.2')).to be <= Version.new('1.2')
end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
-
- it 'compares versions and returns true' do
- expect(first).to be <= second
+ it 'is true for smaller version' do
+ expect(Version.new('1.3')).to be <= Version.new('1.3.1')
end
- it 'compares versions and returns false' do
- expect(second).to_not be <= first
+ it 'is false for larger version' do
+ expect(Version.new('1.3.1')).to_not be <= Version.new('1.3')
end
- it 'compares equal versions and returns true' do
- first_with_zero = Version.new '1.3.0'
- expect(first).to be <= first_with_zero
+ it 'is true for equal versions' do
+ expect(Version.new('1.3')).to be <= Version.new('1.3.0')
end
end
end
describe '#>=' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares versions and returns true' do
- expect(second).to be >= first
+ it 'is true for larger version' do
+ expect(Version.new('1.3')).to be >= Version.new('1.2')
end
- it 'compares versions and returns false' do
- expect(first).to_not be >= second
+ it 'is false for smaller version' do
+ expect(Version.new('1.2')).to_not be >= Version.new('1.3')
end
- it 'compares equal versions and returns true' do
- expect(first).to be >= first
+ it 'is true for equal versions' do
+ expect(Version.new('1.2')).to be >= Version.new('1.2')
end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
-
- it 'compares versions and returns true' do
- expect(second).to be >= first
+ it 'is true for larger version' do
+ expect(Version.new('1.3.1')).to be >= Version.new('1.3')
end
- it 'compares versions and returns false' do
- expect(first).to_not be >= second
+ it 'is false for smaller version' do
+ expect(Version.new('1.3')).to_not be >= Version.new('1.3.1')
end
- it 'compares equal versions and returns true' do
- first_with_zero = Version.new '1.3.0'
- expect(first).to be >= first_with_zero
+ it 'is true for equal versions' do
+ expect(Version.new('1.3')).to be >= Version.new('1.3.0')
end
end
end
describe '#==' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares versions and returns false' do
- expect(second).to_not be == first
+ it 'is false for non-equal versions' do
+ expect(Version.new('1.2')).to_not be == Version.new('1.3')
+ expect(Version.new('1.3')).to_not be == Version.new('1.2')
end
- it 'compares versions and returns false' do
- expect(first).to_not be == second
+ it 'is true for equal versions' do
+ expect(Version.new('1.2')).to be == Version.new('1.2')
end
-
- it 'compares equal versions and returns true' do
- expect(first).to be == first
- end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
-
- it 'compares versions and returns true' do
- expect(second).to_not be == first
+ it 'is false for non-equal versions' do
+ expect(Version.new('1.3.1')).to_not be == Version.new('1.3')
+ expect(Version.new('1.3')).to_not be == Version.new('1.3.1')
end
- it 'compares versions and returns true' do
- expect(first).to_not be == second
+ it 'is true for equal versions' do
+ expect(Version.new('1.3')).to be == Version.new('1.3.0')
end
-
- it 'compares equal versions and returns true' do
- first_with_zero = Version.new '1.3.0'
- expect(first).to be == first_with_zero
- end
end
end
describe '#<=>' do
context 'when versions have equal length' do
- let(:first) { Version.new '1.2' }
- let(:second) { Version.new '1.3' }
-
- it 'compares different versions' do
- expect(first <=> second).to eq -1
+ it 'compares smaller with larger version' do
+ expect(Version.new('1.2') <=> Version.new('1.3')).to eq -1
end
- it 'compares different versions' do
- expect(second <=> first).to eq 1
+ it 'compares larger with smaller version' do
+ expect(Version.new('1.3') <=> Version.new('1.2')).to eq 1
end
it 'compares equal versions' do
- equal_to_first = Version.new('1.2')
- expect(first <=> equal_to_first).to eq 0
+ version = Version.new('1.2')
+ expect(version <=> Version.new('1.2')).to eq 0
end
end
context 'when versions have different length' do
- let(:first) { Version.new '1.3' }
- let(:second) { Version.new '1.3.1' }
+ let(:first) { Version.new('1.3') }
+ let(:second) { Version.new('1.3.1') }
- it 'compares different versions' do
- expect(first <=> second).to eq -1
+ it 'compares smaller with larger version' do
+ expect(Version.new('1.3') <=> Version.new('1.3.1')).to eq -1
end
- it 'compares different versions' do
- expect(second <=> first).to eq 1
+ it 'compares larger with smaller version' do
+ expect(Version.new('1.3.1') <=> Version.new('1.3')).to eq 1
end
it 'compares equal versions' do
- first_with_zero = Version.new '1.3.0'
- expect(first <=> first_with_zero).to eq 0
+ expect(Version.new('1.3') <=> Version.new('1.3.0')).to eq 0
end
end
end
describe '#to_s' do
context 'when version does not have ending zeros' do
it 'shows basic version' do
- version = '1.3'
- expect(Version.new(version).to_s).to eq version
+ expect(Version.new('1.3').to_s).to eq '1.3'
end
it 'shows the empty version' do
- version = ''
- expect(Version.new(version).to_s).to eq version
+ expect(Version.new('').to_s).to eq ''
end
end
context 'when version has ending zeros' do
it 'shows basic version' do
- version = '1.3.0'
- expect(Version.new(version).to_s).to eq '1.3'
+ expect(Version.new('1.3.0').to_s).to eq '1.3'
end
it 'shows the 0 version' do
- version = '0'
- expect(Version.new(version).to_s).to eq ''
+ expect(Version.new('0').to_s).to eq ''
end
end
end
describe '#components' do
context 'when no optional argument is given' do
it 'gets simple version' do
- version = '1.2'
- expect(Version.new(version).components).to eq([1, 2])
+ expect(Version.new('1.2').components).to eq([1, 2])
end
it 'gets version ending with zero' do
- version = '1.2.0'
- expect(Version.new(version).components).to eq([1, 2])
+ expect(Version.new('1.2.0').components).to eq([1, 2])
end
it 'does not modify the version' do
version = Version.new('1.2')
- component = version.components
- new_component = component.dup
- component.push 10
- expect(version.components).to eq(new_component)
+ version.components.push -1
+
+ expect(version.components).to eq([1, 2])
end
end
context 'when optional argument is given' do
it 'gets simple version with fewer elements' do
- version = '1.2.3'
- expect(Version.new(version).components(5)).to eq([1, 2, 3, 0, 0])
+ expect(Version.new('1.2.3').components(5)).to eq([1, 2, 3, 0, 0])
end
it 'gets simple version with more elements' do
- version = '1.2.3'
- expect(Version.new(version).components(2)).to eq([1, 2])
+ expect(Version.new('1.2.3').components(2)).to eq([1, 2])
end
it 'gets simple version with equal amount of elements' do
- version = '1.2.3'
- expect(Version.new(version).components(3)).to eq([1, 2, 3])
+ expect(Version.new('1.2.3').components(3)).to eq([1, 2, 3])
end
end
end
describe '#Version::Range' do
describe '#initialize' do
it 'does not raise error with valid versions' do
expect { Version::Range.new('1.2.3', '1.2.4') }.to_not raise_error
end
it 'raises error with invalid versions' do
version = '..3'
expect { Version::Range.new(version, '1.2.4') }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
end
describe '#include?' do
it 'returns true for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.5')).to be true
end
it 'returns false for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.2')).to be false
end
it 'returns false when version is equal to last version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.9')).to be false
end
it 'returns true when version is equal to first version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.3')).to be true
end
end
describe '#to_a' do
it 'shows for simple range' do
range = Version::Range.new('1.2.6', '1.3.1')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2.6', '1.2.7',
'1.2.8', '1.2.9', '1.3'
]
)
end
it 'shows for range with shorter version' do
range = Version::Range.new('1.2', '1.3')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2', '1.2.1', '1.2.2',
'1.2.3', '1.2.4', '1.2.5',
'1.2.6', '1.2.7', '1.2.8', '1.2.9'
]
)
end
it 'shows for range with no versions' do
range = Version::Range.new('1.2', '1.2')
expect(range.to_a.map(&:to_s)).to eq([])
end
end
end
end

Петко обнови решението на 18.11.2016 23:42 (преди около 9 години)

RSpec.describe 'Version' do
describe '#initialize' do
it 'does not raise error with empty string' do
expect { Version.new '' }.to_not raise_error
end
it 'does not raise error with valid version' do
expect { Version.new '1.2.3' }.to_not raise_error
end
it 'raises error with invalid version' do
version = '1..2'
expect { Version.new version }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
it 'does not raise error with no arguments' do
expect { Version.new }.to_not raise_error
end
it 'does not raise error with version instance' do
expect { Version.new Version.new }.to_not raise_error
end
end
describe '#<' do
context 'when versions have equal length' do
it 'is true for smaller version' do
expect(Version.new('1.2')).to be < Version.new('1.3')
end
it 'is false for larger version' do
expect(Version.new('1.3')).to_not be < Version.new('1.2')
end
it 'is false for equal versions' do
expect(Version.new('1.2')).to_not be < Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for smaller version' do
expect(Version.new('1.3')).to be < Version.new('1.3.1')
end
it 'is false for larger version' do
expect(Version.new('1.3.1')).to_not be < Version.new('1.3')
end
it 'is false for equal versions' do
expect(Version.new('1.3')).to_not be < Version.new('1.3.0')
end
end
end
describe '#>' do
context 'when versions have equal length' do
it 'is true for larger version' do
expect(Version.new('1.3')).to be > Version.new('1.2')
end
it 'is false for smaller version' do
expect(Version.new('1.2')).to_not be > Version.new('1.3')
end
it 'is false for equal versions' do
expect(Version.new('1.2')).to_not be > Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for larger version' do
expect(Version.new('1.3.1')).to be > Version.new('1.3')
end
it 'is false for smaller version' do
expect(Version.new('1.3')).to_not be > Version.new('1.3.1')
end
it 'is false for equal versions' do
expect(Version.new('1.3')).to_not be > Version.new('1.3.0')
end
end
end
describe '#<=' do
context 'when versions have equal length' do
it 'is true for smaller version' do
expect(Version.new('1.2')).to be <= Version.new('1.3')
end
it 'is false for larger version' do
expect(Version.new('1.3')).to_not be <= Version.new('1.2')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be <= Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for smaller version' do
expect(Version.new('1.3')).to be <= Version.new('1.3.1')
end
it 'is false for larger version' do
expect(Version.new('1.3.1')).to_not be <= Version.new('1.3')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be <= Version.new('1.3.0')
end
end
end
describe '#>=' do
context 'when versions have equal length' do
it 'is true for larger version' do
expect(Version.new('1.3')).to be >= Version.new('1.2')
end
it 'is false for smaller version' do
expect(Version.new('1.2')).to_not be >= Version.new('1.3')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be >= Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is true for larger version' do
expect(Version.new('1.3.1')).to be >= Version.new('1.3')
end
it 'is false for smaller version' do
expect(Version.new('1.3')).to_not be >= Version.new('1.3.1')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be >= Version.new('1.3.0')
end
end
end
describe '#==' do
context 'when versions have equal length' do
it 'is false for non-equal versions' do
expect(Version.new('1.2')).to_not be == Version.new('1.3')
expect(Version.new('1.3')).to_not be == Version.new('1.2')
end
it 'is true for equal versions' do
expect(Version.new('1.2')).to be == Version.new('1.2')
end
end
context 'when versions have different length' do
it 'is false for non-equal versions' do
expect(Version.new('1.3.1')).to_not be == Version.new('1.3')
expect(Version.new('1.3')).to_not be == Version.new('1.3.1')
end
it 'is true for equal versions' do
expect(Version.new('1.3')).to be == Version.new('1.3.0')
end
end
end
describe '#<=>' do
context 'when versions have equal length' do
it 'compares smaller with larger version' do
expect(Version.new('1.2') <=> Version.new('1.3')).to eq -1
end
it 'compares larger with smaller version' do
expect(Version.new('1.3') <=> Version.new('1.2')).to eq 1
end
it 'compares equal versions' do
version = Version.new('1.2')
expect(version <=> Version.new('1.2')).to eq 0
end
end
context 'when versions have different length' do
- let(:first) { Version.new('1.3') }
- let(:second) { Version.new('1.3.1') }
-
it 'compares smaller with larger version' do
expect(Version.new('1.3') <=> Version.new('1.3.1')).to eq -1
end
it 'compares larger with smaller version' do
expect(Version.new('1.3.1') <=> Version.new('1.3')).to eq 1
end
it 'compares equal versions' do
expect(Version.new('1.3') <=> Version.new('1.3.0')).to eq 0
end
end
end
describe '#to_s' do
context 'when version does not have ending zeros' do
it 'shows basic version' do
expect(Version.new('1.3').to_s).to eq '1.3'
end
it 'shows the empty version' do
expect(Version.new('').to_s).to eq ''
end
end
context 'when version has ending zeros' do
it 'shows basic version' do
expect(Version.new('1.3.0').to_s).to eq '1.3'
end
it 'shows the 0 version' do
expect(Version.new('0').to_s).to eq ''
end
end
end
describe '#components' do
context 'when no optional argument is given' do
it 'gets simple version' do
expect(Version.new('1.2').components).to eq([1, 2])
end
it 'gets version ending with zero' do
expect(Version.new('1.2.0').components).to eq([1, 2])
end
it 'does not modify the version' do
version = Version.new('1.2')
version.components.push -1
expect(version.components).to eq([1, 2])
end
end
context 'when optional argument is given' do
it 'gets simple version with fewer elements' do
expect(Version.new('1.2.3').components(5)).to eq([1, 2, 3, 0, 0])
end
it 'gets simple version with more elements' do
expect(Version.new('1.2.3').components(2)).to eq([1, 2])
end
it 'gets simple version with equal amount of elements' do
expect(Version.new('1.2.3').components(3)).to eq([1, 2, 3])
end
end
end
describe '#Version::Range' do
describe '#initialize' do
it 'does not raise error with valid versions' do
expect { Version::Range.new('1.2.3', '1.2.4') }.to_not raise_error
end
it 'raises error with invalid versions' do
version = '..3'
expect { Version::Range.new(version, '1.2.4') }.to raise_error(
ArgumentError,
"Invalid version string '#{version}'"
)
end
end
describe '#include?' do
it 'returns true for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.5')).to be true
end
it 'returns false for simple version' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.2')).to be false
end
it 'returns false when version is equal to last version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.9')).to be false
end
it 'returns true when version is equal to first version in range' do
range = Version::Range.new('1.2.3', '1.2.9')
expect(range.include?('1.2.3')).to be true
end
end
describe '#to_a' do
it 'shows for simple range' do
range = Version::Range.new('1.2.6', '1.3.1')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2.6', '1.2.7',
'1.2.8', '1.2.9', '1.3'
]
)
end
it 'shows for range with shorter version' do
range = Version::Range.new('1.2', '1.3')
expect(range.to_a.map(&:to_s)).to eq(
[
'1.2', '1.2.1', '1.2.2',
'1.2.3', '1.2.4', '1.2.5',
'1.2.6', '1.2.7', '1.2.8', '1.2.9'
]
)
end
it 'shows for range with no versions' do
range = Version::Range.new('1.2', '1.2')
expect(range.to_a.map(&:to_s)).to eq([])
end
end
end
end