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

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

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

Решение на Четвърта задача - Unit тестване от Добрин Цветков

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

Към профила на Добрин Цветков

Резултати

  • 5 точки от тестове
  • 0 бонус точки
  • 5 точки общо
  • 15 успешни тест(а)
  • 4 неуспешни тест(а)

Код

RSpec.describe 'Version' do
context 'Upon creating a new Version variable' do
it 'accepts zero version through empty string' do
Version.new('')
end
it 'accepts zero version through no arguments' do
Version.new
end
it 'accepts correct versions through strings' do
expect { Version.new('1.3.5') }.to_not raise_error
expect { Version.new('3.14.12') }.to_not raise_error
expect { Version.new('2.5.0') }.to_not raise_error
end
it 'accepts correct versions through other version instance' do
expect { Version.new(Version.new('1.3.5')) }.to_not raise_error
end
it 'rejects incorrect versions through strings' do
expect { Version.new('.9.1') }.to raise_error(ArgumentError)
expect { Version.new('5..2') }.to raise_error(ArgumentError)
end
it 'rejects incorrect versions through other version instance' do
expect { Version.new(Version.new('.9.1')) }.to raise_error(ArgumentError)
end
end
context 'Upon comparing versions' do
it 'compares equal versions' do
expect(Version.new('1.1.0') == Version.new('1.1')).to eq true
end
it 'compares non-equal versions' do
expect(Version.new('5.3.2') < Version.new('9')).to eq true
expect(Version.new('5.3.2') > Version.new('2.3.0')).to eq true
end
it 'compares with spaceship operator' do
expect(Version.new('5.3.2') <=> Version.new('9')).to eq -1
expect(Version.new('5.3.2') <=> Version.new('2.3.0')).to eq 1
expect(Version.new('5.3.2') <=> Version.new('5.3.2.0')).to eq 0
end
end
context 'Upon string conversions' do
it 'converts the zero version' do
expect(Version.new('').to_s).to eq ''
expect(Version.new.to_s).to eq ''
end
it 'converts when version does not end in zeros' do
expect(Version.new('12.4.2').to_s).to eq '12.4.2'
end
it 'converts when version ends in zeros' do
expect(Version.new('5.1.3.0.0').to_s).to eq '5.1.3'
end
end
context 'Upon calling components method' do
context 'When number of arguments is not set' do
it 'works when version ends in zeros' do
expect(Version.new('4.2.0.0.0').components).to eq [4, 2]
end
it 'works when version doesn\'t end in zeros' do
expect(Version.new('4.2').components).to eq [4, 2]
end
end
context 'When number of arguments is set' do
it 'works when number of arguments is less than version length' do
expect(Version.new('2.4.16').components(2)).to eq [2, 4]
end
it 'works when number of arguments is greater than version length' do
expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
end
end
it 'does not allow modifications to version' do
version = Version.new('1.2.3.4')
components = version.components
expect(version.components.equal?(components)).to eq false
components[3] = 5
expect(version.to_s).to_not eq '1.2.3.5'
expect(version.to_s).to eq '1.2.3.4'
end
end
describe 'Range' do
context 'When initializing' do
it 'works with two strings' do
Version::Range.new('1.2.3', '4.5.6')
end
it 'works with two Version variables' do
Version::Range.new(Version.new('1'), Version.new('2'))
end
end
context 'When using include?' do
it 'checks versions in between when argument is a Version' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?(Version.new('3.5.4.6.2'))).to eq true
end
it 'checks versions outside of range when argument is a Version' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?(Version.new('7.1.2'))).to eq false
end
it 'checks versions in between when argument is a string' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?('3.5.4.6.2')).to eq true
end
it 'checks versions outside of range when argument is a string' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?('7.1.2')).to eq false
end
end
context 'When using to_a' do
it 'includes start version' do
version_range = Version::Range.new('1', '1.0.1')
expect(version_range.to_a).to eq [1]
end
it 'excludes end version' do
version_range = Version::Range.new('1', '1')
expect(version_range.to_a).to eq []
end
it 'generates correct array' do
version_range_array = Version::Range.new('2.5', '2.5.7').to_a
arr = ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4', '2.5.5', '2.5.6']
expect(version_range_array).to eq arr
end
end
end
end

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

.F...FF.........F..

Failures:

  1) spec Version checks for ArgumentError with the correct message
     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"
             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)
               @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-y5uj94/spec.rb:257: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)>'

  2) spec Version checks for comparison operators positively
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
         def <=(other)
           false
         end
           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)
               @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-y5uj94/spec.rb:341: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)>'

  3) spec Version checks for comparison operators negatively
     Failure/Error: expect(@solution).to_not pass_tests
       expected this solution to not pass the tests:
       
         class Version
         def >(other)
           true
         end
           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)
               @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-y5uj94/spec.rb:359: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)>'

  4) spec Version::Range tests include? with versions lower than the start one
     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)
               @start_version = Version.new(start_version)
               @end_version   = Version.new(end_version)
             end
         
             def include?(version)
               @end_version > version
             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-y5uj94/spec.rb:522: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 15.52 seconds
19 examples, 4 failures

Failed examples:

rspec /tmp/d20161119-19072-y5uj94/spec.rb:241 # spec Version checks for ArgumentError with the correct message
rspec /tmp/d20161119-19072-y5uj94/spec.rb:317 # spec Version checks for comparison operators positively
rspec /tmp/d20161119-19072-y5uj94/spec.rb:353 # spec Version checks for comparison operators negatively
rspec /tmp/d20161119-19072-y5uj94/spec.rb:515 # spec Version::Range tests include? with versions lower than the start one

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

Добрин обнови решението на 13.11.2016 20:14 (преди над 8 години)

+RSpec.describe 'Version' do
+ context 'Upon creating a new Version variable' do
+ it 'accepts zero version through empty string' do
+ begin
+ Version.new('')
+ rescue ArgumentError
+ pred = 0
+ else
+ pred = 1
+ end
+
+ expect(pred).to eq 1
+ end
+
+ it 'accepts zero version through no arguments' do
+ begin
+ Version.new
+ rescue ArgumentError
+ pred = 0
+ else
+ pred = 1
+ end
+
+ expect(pred).to eq 1
+ end
+
+ it 'accepts correct versions' do
+ begin
+ Version.new('1.3.5')
+ Version.new('3.14.12')
+ Version.new('2.5.0')
+ rescue ArgumentError
+ pred = 0
+ else
+ pred = 1
+ end
+
+ expect(pred).to eq 1
+ end
+
+ it 'rejects incorrect versions' do
+ begin
+ Version.new('.9.1')
+ rescue ArgumentError
+ pred1 = 0
+ else
+ pred1 = 1
+ end
+
+ expect(pred1).to eq 0
+
+ begin
+ Version.new('5..2')
+ rescue ArgumentError
+ pred2 = 0
+ else
+ pred2 = 1
+ end
+
+ expect(pred2).to eq 0
+ end
+ end
+
+ context 'Upon comparing versions' do
+ it 'compares equal versions' do
+ expect(Version.new('1.1.0') <=> Version.new('1.1')).to eq 0
+ end
+
+ it 'compares non-equal versions' do
+ expect(Version.new('5.3.2') < Version.new('9')).to eq true
+ expect(Version.new('5.3.2') <=> Version.new('2.3.0')).to eq 1
+ end
+ end
+
+ context 'Upon string conversions' do
+ it 'converts the zero version' do
+ expect(Version.new('').to_s).to eq ''
+ expect(Version.new.to_s).to eq ''
+ end
+
+ it 'converts when version does not end in zeros' do
+ expect(Version.new('12.4.2').to_s).to eq '12.4.2'
+ end
+
+ it 'converts when version ends in zeros' do
+ expect(Version.new('5.1.3.0.0').to_s).to eq '5.1.3'
+ end
+ end
+
+ context 'Upon calling components method' do
+ it 'works when number of arguments is not set' do
+ expect(Version.new('4.2.0').components).to eq [4, 2]
+ end
+
+ it 'works when number of arguments is less than version length' do
+ expect(Version.new('2.4.16').components(2)).to eq [2, 4]
+ end
+
+ it 'works when number of arguments is greater than version length' do
+ expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
+ end
+
+ it 'does not allow modifications to version' do
+ version = Version.new('1.2.3.4')
+ components = version.components
+ expect(version.components.equal?(components)).to eq false
+ components[3] = 5
+ expect(version.to_s).to eq '1.2.3.4'
+ end
+ end
+
+ describe 'Range' do
+ context 'When initializing' do
+ it 'works with two strings' do
+ begin
+ Version::Range.new('1.2.3', '4.5.6')
+ rescue ArgumentError
+ pred = 0
+ else
+ pred = 1
+ end
+ expect(pred).to eq 1
+ end
+
+ it 'works with two Version variables' do
+ begin
+ Version::Range.new(Version.new('1'), Version.new('2'))
+ rescue ArgumentError
+ pred = 0
+ else
+ pred = 1
+ end
+ expect(pred).to eq 1
+ end
+ end
+
+ context 'When using include?' do
+ it 'checks versions in between when argument is a Version' do
+ version_range = Version::Range.new('1', '5')
+ expect(version_range.include?(Version.new('3.5.4.6.2'))).to eq true
+ end
+
+ it 'checks versions outside of range when argument is a Version' do
+ version_range = Version::Range.new('2', '3')
+ expect(version_range.include?(Version.new('7.1.2'))).to eq false
+ end
+
+ it 'checks versions in between when argument is a string' do
+ version_range = Version::Range.new('1', '5')
+ expect(version_range.include?('3.5.4.6.2')).to eq true
+ end
+
+ it 'checks versions outside of range when argument is a string' do
+ version_range = Version::Range.new('2', '3')
+ expect(version_range.include?('7.1.2')).to eq false
+ end
+ end
+
+ context 'When using to_a' do
+ it 'includes start version' do
+ version_range = Version::Range.new('1', '1.0.1')
+ expect(version_range.to_a).to eq [1]
+ end
+
+ it 'excludes end version' do
+ version_range = Version::Range.new('1', '1')
+ expect(version_range.to_a).to eq []
+ end
+
+ it 'generates correct array' do
+ version_range_array = Version::Range.new('2.5', '2.5.7').to_a
+ arr = ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4', '2.5.5', '2.5.6']
+ expect(version_range_array).to eq arr
+ end
+ end
+ end
+end

Добрин обнови решението на 14.11.2016 09:35 (преди над 8 години)

RSpec.describe 'Version' do
context 'Upon creating a new Version variable' do
it 'accepts zero version through empty string' do
- begin
- Version.new('')
- rescue ArgumentError
- pred = 0
- else
- pred = 1
- end
-
- expect(pred).to eq 1
+ expect { Version.new('') }.to_not raise_error(ArgumentError)
end
it 'accepts zero version through no arguments' do
- begin
- Version.new
- rescue ArgumentError
- pred = 0
- else
- pred = 1
- end
-
- expect(pred).to eq 1
+ expect { Version.new }.to_not raise_error(ArgumentError)
end
it 'accepts correct versions' do
- begin
- Version.new('1.3.5')
- Version.new('3.14.12')
- Version.new('2.5.0')
- rescue ArgumentError
- pred = 0
- else
- pred = 1
- end
-
- expect(pred).to eq 1
+ expect { Version.new('1.3.5') }.to_not raise_error(ArgumentError)
+ expect { Version.new('3.14.12') }.to_not raise_error(ArgumentError)
+ expect { Version.new('2.5.0') }.to_not raise_error(ArgumentError)
end
it 'rejects incorrect versions' do
- begin
- Version.new('.9.1')
- rescue ArgumentError
- pred1 = 0
- else
- pred1 = 1
- end
-
- expect(pred1).to eq 0
-
- begin
- Version.new('5..2')
- rescue ArgumentError
- pred2 = 0
- else
- pred2 = 1
- end
-
- expect(pred2).to eq 0
+ expect { Version.new('.9.1') }.to raise_error(ArgumentError)
+ expect { Version.new('5..2') }.to raise_error(ArgumentError)
end
end
context 'Upon comparing versions' do
it 'compares equal versions' do
expect(Version.new('1.1.0') <=> Version.new('1.1')).to eq 0
end
it 'compares non-equal versions' do
expect(Version.new('5.3.2') < Version.new('9')).to eq true
expect(Version.new('5.3.2') <=> Version.new('2.3.0')).to eq 1
end
end
context 'Upon string conversions' do
it 'converts the zero version' do
expect(Version.new('').to_s).to eq ''
expect(Version.new.to_s).to eq ''
end
it 'converts when version does not end in zeros' do
expect(Version.new('12.4.2').to_s).to eq '12.4.2'
end
it 'converts when version ends in zeros' do
expect(Version.new('5.1.3.0.0').to_s).to eq '5.1.3'
end
end
context 'Upon calling components method' do
it 'works when number of arguments is not set' do
expect(Version.new('4.2.0').components).to eq [4, 2]
end
it 'works when number of arguments is less than version length' do
expect(Version.new('2.4.16').components(2)).to eq [2, 4]
end
it 'works when number of arguments is greater than version length' do
expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
end
it 'does not allow modifications to version' do
version = Version.new('1.2.3.4')
components = version.components
expect(version.components.equal?(components)).to eq false
components[3] = 5
expect(version.to_s).to eq '1.2.3.4'
end
end
describe 'Range' do
context 'When initializing' do
it 'works with two strings' do
- begin
- Version::Range.new('1.2.3', '4.5.6')
- rescue ArgumentError
- pred = 0
- else
- pred = 1
- end
- expect(pred).to eq 1
+ expect { Version::Range.new('1.2.3', '4.5.6') }
+ .to_not raise_error(ArgumentError)
end
it 'works with two Version variables' do
- begin
- Version::Range.new(Version.new('1'), Version.new('2'))
- rescue ArgumentError
- pred = 0
- else
- pred = 1
- end
- expect(pred).to eq 1
+ expect { Version::Range.new(Version.new('1'), Version.new('2')) }
+ .to_not raise_error(ArgumentError)
end
end
context 'When using include?' do
it 'checks versions in between when argument is a Version' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?(Version.new('3.5.4.6.2'))).to eq true
end
it 'checks versions outside of range when argument is a Version' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?(Version.new('7.1.2'))).to eq false
end
it 'checks versions in between when argument is a string' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?('3.5.4.6.2')).to eq true
end
it 'checks versions outside of range when argument is a string' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?('7.1.2')).to eq false
end
end
context 'When using to_a' do
it 'includes start version' do
version_range = Version::Range.new('1', '1.0.1')
expect(version_range.to_a).to eq [1]
end
it 'excludes end version' do
version_range = Version::Range.new('1', '1')
expect(version_range.to_a).to eq []
end
it 'generates correct array' do
version_range_array = Version::Range.new('2.5', '2.5.7').to_a
arr = ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4', '2.5.5', '2.5.6']
expect(version_range_array).to eq arr
end
end
end
end

Добрин обнови решението на 14.11.2016 15:43 (преди над 8 години)

RSpec.describe 'Version' do
context 'Upon creating a new Version variable' do
it 'accepts zero version through empty string' do
- expect { Version.new('') }.to_not raise_error(ArgumentError)
+ Version.new('')
end
it 'accepts zero version through no arguments' do
- expect { Version.new }.to_not raise_error(ArgumentError)
+ Version.new
end
it 'accepts correct versions' do
- expect { Version.new('1.3.5') }.to_not raise_error(ArgumentError)
- expect { Version.new('3.14.12') }.to_not raise_error(ArgumentError)
- expect { Version.new('2.5.0') }.to_not raise_error(ArgumentError)
+ expect { Version.new('1.3.5') }.to_not raise_error
+ expect { Version.new('3.14.12') }.to_not raise_error
+ expect { Version.new('2.5.0') }.to_not raise_error
end
it 'rejects incorrect versions' do
expect { Version.new('.9.1') }.to raise_error(ArgumentError)
expect { Version.new('5..2') }.to raise_error(ArgumentError)
end
end
context 'Upon comparing versions' do
it 'compares equal versions' do
- expect(Version.new('1.1.0') <=> Version.new('1.1')).to eq 0
+ expect(Version.new('1.1.0') == Version.new('1.1')).to eq true
end
it 'compares non-equal versions' do
expect(Version.new('5.3.2') < Version.new('9')).to eq true
- expect(Version.new('5.3.2') <=> Version.new('2.3.0')).to eq 1
+ expect(Version.new('5.3.2') > Version.new('2.3.0')).to eq true
end
end
context 'Upon string conversions' do
it 'converts the zero version' do
expect(Version.new('').to_s).to eq ''
expect(Version.new.to_s).to eq ''
end
it 'converts when version does not end in zeros' do
expect(Version.new('12.4.2').to_s).to eq '12.4.2'
end
it 'converts when version ends in zeros' do
expect(Version.new('5.1.3.0.0').to_s).to eq '5.1.3'
end
end
context 'Upon calling components method' do
it 'works when number of arguments is not set' do
expect(Version.new('4.2.0').components).to eq [4, 2]
end
it 'works when number of arguments is less than version length' do
expect(Version.new('2.4.16').components(2)).to eq [2, 4]
end
it 'works when number of arguments is greater than version length' do
expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
end
it 'does not allow modifications to version' do
version = Version.new('1.2.3.4')
components = version.components
expect(version.components.equal?(components)).to eq false
components[3] = 5
expect(version.to_s).to eq '1.2.3.4'
end
end
describe 'Range' do
context 'When initializing' do
it 'works with two strings' do
- expect { Version::Range.new('1.2.3', '4.5.6') }
- .to_not raise_error(ArgumentError)
+ Version::Range.new('1.2.3', '4.5.6')
end
it 'works with two Version variables' do
- expect { Version::Range.new(Version.new('1'), Version.new('2')) }
- .to_not raise_error(ArgumentError)
+ Version::Range.new(Version.new('1'), Version.new('2'))
end
end
context 'When using include?' do
it 'checks versions in between when argument is a Version' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?(Version.new('3.5.4.6.2'))).to eq true
end
it 'checks versions outside of range when argument is a Version' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?(Version.new('7.1.2'))).to eq false
end
it 'checks versions in between when argument is a string' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?('3.5.4.6.2')).to eq true
end
it 'checks versions outside of range when argument is a string' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?('7.1.2')).to eq false
end
end
context 'When using to_a' do
it 'includes start version' do
version_range = Version::Range.new('1', '1.0.1')
expect(version_range.to_a).to eq [1]
end
it 'excludes end version' do
version_range = Version::Range.new('1', '1')
expect(version_range.to_a).to eq []
end
it 'generates correct array' do
version_range_array = Version::Range.new('2.5', '2.5.7').to_a
arr = ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4', '2.5.5', '2.5.6']
expect(version_range_array).to eq arr
end
end
end
end

Добрин обнови решението на 18.11.2016 11:56 (преди над 8 години)

RSpec.describe 'Version' do
context 'Upon creating a new Version variable' do
it 'accepts zero version through empty string' do
Version.new('')
end
it 'accepts zero version through no arguments' do
Version.new
end
- it 'accepts correct versions' do
+ it 'accepts correct versions through strings' do
expect { Version.new('1.3.5') }.to_not raise_error
expect { Version.new('3.14.12') }.to_not raise_error
expect { Version.new('2.5.0') }.to_not raise_error
end
- it 'rejects incorrect versions' do
+ it 'accepts correct versions through other version instance' do
+ expect { Version.new(Version.new('1.3.5')) }.to_not raise_error
+ end
+
+ it 'rejects incorrect versions through strings' do
expect { Version.new('.9.1') }.to raise_error(ArgumentError)
expect { Version.new('5..2') }.to raise_error(ArgumentError)
end
+
+ it 'rejects incorrect versions through other version instance' do
+ expect { Version.new(Version.new('.9.1')) }.to raise_error(ArgumentError)
+ end
end
context 'Upon comparing versions' do
it 'compares equal versions' do
expect(Version.new('1.1.0') == Version.new('1.1')).to eq true
end
it 'compares non-equal versions' do
expect(Version.new('5.3.2') < Version.new('9')).to eq true
expect(Version.new('5.3.2') > Version.new('2.3.0')).to eq true
end
+
+ it 'compares with spaceship operator' do
+ expect(Version.new('5.3.2') <=> Version.new('9')).to eq -1
+ expect(Version.new('5.3.2') <=> Version.new('2.3.0')).to eq 1
+ expect(Version.new('5.3.2') <=> Version.new('5.3.2.0')).to eq 0
+ end
end
context 'Upon string conversions' do
it 'converts the zero version' do
expect(Version.new('').to_s).to eq ''
expect(Version.new.to_s).to eq ''
end
it 'converts when version does not end in zeros' do
expect(Version.new('12.4.2').to_s).to eq '12.4.2'
end
it 'converts when version ends in zeros' do
expect(Version.new('5.1.3.0.0').to_s).to eq '5.1.3'
end
end
context 'Upon calling components method' do
- it 'works when number of arguments is not set' do
- expect(Version.new('4.2.0').components).to eq [4, 2]
- end
+ context 'When number of arguments is not set' do
+ it 'works when version ends in zeros' do
+ expect(Version.new('4.2.0.0.0').components).to eq [4, 2]
+ end
- it 'works when number of arguments is less than version length' do
- expect(Version.new('2.4.16').components(2)).to eq [2, 4]
+ it 'works when version doesn\'t end in zeros' do
+ expect(Version.new('4.2').components).to eq [4, 2]
+ end
end
- it 'works when number of arguments is greater than version length' do
- expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
+ context 'When number of arguments is set' do
+ it 'works when number of arguments is less than version length' do
+ expect(Version.new('2.4.16').components(2)).to eq [2, 4]
+ end
+
+ it 'works when number of arguments is greater than version length' do
+ expect(Version.new('6.8').components(5)).to eq [6, 8, 0, 0, 0]
+ end
end
it 'does not allow modifications to version' do
version = Version.new('1.2.3.4')
components = version.components
expect(version.components.equal?(components)).to eq false
components[3] = 5
+ expect(version.to_s).to_not eq '1.2.3.5'
expect(version.to_s).to eq '1.2.3.4'
end
end
describe 'Range' do
context 'When initializing' do
it 'works with two strings' do
Version::Range.new('1.2.3', '4.5.6')
end
it 'works with two Version variables' do
Version::Range.new(Version.new('1'), Version.new('2'))
end
end
context 'When using include?' do
it 'checks versions in between when argument is a Version' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?(Version.new('3.5.4.6.2'))).to eq true
end
it 'checks versions outside of range when argument is a Version' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?(Version.new('7.1.2'))).to eq false
end
it 'checks versions in between when argument is a string' do
version_range = Version::Range.new('1', '5')
expect(version_range.include?('3.5.4.6.2')).to eq true
end
it 'checks versions outside of range when argument is a string' do
version_range = Version::Range.new('2', '3')
expect(version_range.include?('7.1.2')).to eq false
end
end
context 'When using to_a' do
it 'includes start version' do
version_range = Version::Range.new('1', '1.0.1')
expect(version_range.to_a).to eq [1]
end
it 'excludes end version' do
version_range = Version::Range.new('1', '1')
expect(version_range.to_a).to eq []
end
it 'generates correct array' do
version_range_array = Version::Range.new('2.5', '2.5.7').to_a
arr = ['2.5', '2.5.1', '2.5.2', '2.5.3', '2.5.4', '2.5.5', '2.5.6']
expect(version_range_array).to eq arr
end
end
end
end