rubygems-update 2.1.11 → 2.2.0.rc.1

data/test/rubygems/test_gem_requirement.rb

@@ -3,6 +3,14 @@ require "rubygems/requirement"
 
 class TestGemRequirement < Gem::TestCase
 
+  def test_concat
+    r = req '>= 1'
+
+    r.concat ['< 2']
+
+    assert_equal [['>=', v(1)], ['<', v(2)]], r.requirements
+  end
+
   def test_equals2
     r = req "= 1.2"
     assert_equal r, r.dup
@@ -36,6 +44,19 @@ class TestGemRequirement < Gem::TestCase
     assert_equal false, r.none?
   end
 
+  def test_for_lockfile
+    assert_equal ' (~> 1.0)', req('~> 1.0').for_lockfile
+
+    assert_equal ' (~> 1.0, >= 1.0.1)', req('>= 1.0.1', '~> 1.0').for_lockfile
+
+    duped = req '= 1.0'
+    duped.requirements << ['=', v('1.0')]
+
+    assert_equal ' (= 1.0)', duped.for_lockfile
+
+    assert_nil Gem::Requirement.default.for_lockfile
+  end
+
   def test_parse
     assert_equal ['=', Gem::Version.new(1)], Gem::Requirement.parse('  1')
     assert_equal ['=', Gem::Version.new(1)], Gem::Requirement.parse('= 1')

data/test/rubygems/{test_gem_dependency_resolver.rb → test_gem_resolver.rb}

@@ -1,7 +1,12 @@
 require 'rubygems/test_case'
-require 'rubygems/dependency_resolver'
 
-class TestGemDependencyResolver < Gem::TestCase
+class TestGemResolver < Gem::TestCase
+
+  def setup
+    super
+
+    @DR = Gem::Resolver
+  end
 
   def make_dep(name, *req)
     Gem::Dependency.new(name, *req)
@@ -11,13 +16,120 @@ class TestGemDependencyResolver < Gem::TestCase
     StaticSet.new(specs)
   end
 
-  def assert_set(expected, actual)
+  def assert_resolves_to expected, resolver
+    actual = resolver.resolve
+
     exp = expected.sort_by { |s| s.full_name }
     act = actual.map { |a| a.spec }.sort_by { |s| s.full_name }
 
     msg = "Set of gems was not the same: #{exp.map { |x| x.full_name}.inspect} != #{act.map { |x| x.full_name}.inspect}"
 
     assert_equal exp, act, msg
+  rescue Gem::DependencyResolutionError => e
+    flunk e.message
+  end
+
+  def test_self_compatibility
+    assert_same Gem::Resolver, Gem::DependencyResolver
+  end
+
+  def test_self_compose_sets_multiple
+    index_set  = @DR::IndexSet.new
+    vendor_set = @DR::VendorSet.new
+
+    composed = @DR.compose_sets index_set, vendor_set
+
+    assert_kind_of Gem::Resolver::ComposedSet, composed
+
+    assert_equal [index_set, vendor_set], composed.sets
+  end
+
+  def test_self_compose_sets_nest
+    index_set  = @DR::IndexSet.new
+    vendor_set = @DR::VendorSet.new
+
+    inner = @DR.compose_sets index_set, vendor_set
+
+    current_set = @DR::CurrentSet.new
+
+    composed = @DR.compose_sets inner, current_set
+
+    assert_kind_of Gem::Resolver::ComposedSet, composed
+
+    assert_equal [index_set, vendor_set, current_set], composed.sets
+  end
+
+  def test_self_compose_sets_nil
+    index_set  = @DR::IndexSet.new
+
+    composed = @DR.compose_sets index_set, nil
+
+    assert_same index_set, composed
+
+    e = assert_raises ArgumentError do
+      @DR.compose_sets nil
+    end
+
+    assert_equal 'one set in the composition must be non-nil', e.message
+  end
+
+  def test_self_compose_sets_single
+    index_set  = @DR::IndexSet.new
+
+    composed = @DR.compose_sets index_set
+
+    assert_same index_set, composed
+  end
+
+  def test_handle_conflict
+    a1 = util_spec 'a', 1
+
+    r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil
+    r2 = Gem::Resolver::DependencyRequest.new dep('a', '= 2'), nil
+    r3 = Gem::Resolver::DependencyRequest.new dep('a', '= 3'), nil
+
+    existing = Gem::Resolver::ActivationRequest.new a1, r1, false
+
+    res = Gem::Resolver.new [a1]
+
+    res.handle_conflict r2, existing
+    res.handle_conflict r2, existing
+    res.handle_conflict r3, existing
+
+    assert_equal 2, res.conflicts.length
+  end
+
+  def test_requests
+    a1 = util_spec 'a', 1, 'b' => 2
+
+    r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil
+
+    act = Gem::Resolver::ActivationRequest.new a1, r1, false
+
+    res = Gem::Resolver.new [a1]
+
+    reqs = Gem::Resolver::RequirementList.new
+
+    res.requests a1, act, reqs
+
+    assert_equal ['b (= 2)'], reqs.to_a.map { |req| req.to_s }
+  end
+
+  def test_requests_ignore_dependencies
+    a1 = util_spec 'a', 1, 'b' => 2
+
+    r1 = Gem::Resolver::DependencyRequest.new dep('a', '= 1'), nil
+
+    act = Gem::Resolver::ActivationRequest.new a1, r1, false
+
+    res = Gem::Resolver.new [a1]
+    res.ignore_dependencies = true
+
+    reqs = Gem::Resolver::RequirementList.new
+
+    res.requests a1, act, reqs
+
+    assert_empty reqs
   end
 
   def test_no_overlap_specificly
@@ -31,9 +143,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a, b)
 
-    res = Gem::DependencyResolver.new(deps, s)
+    res = Gem::Resolver.new(deps, s)
 
-    assert_set [a, b], res.resolve
+    assert_resolves_to [a, b], res
   end
 
   def test_pulls_in_dependencies
@@ -48,9 +160,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a, b, c)
 
-    res = Gem::DependencyResolver.new(deps, s)
+    res = Gem::Resolver.new(deps, s)
 
-    assert_set [a, b, c], res.resolve
+    assert_resolves_to [a, b, c], res
   end
 
   def test_picks_highest_version
@@ -61,16 +173,22 @@ class TestGemDependencyResolver < Gem::TestCase
 
     ad = make_dep "a"
 
-    res = Gem::DependencyResolver.new([ad], s)
+    res = Gem::Resolver.new([ad], s)
 
-    assert_set [a2], res.resolve
+    assert_resolves_to [a2], res
   end
 
   def test_picks_best_platform
-    is = Gem::DependencyResolver::IndexSpecification
+    is      = Gem::Resolver::IndexSpecification
     unknown = Gem::Platform.new 'unknown'
-    a2_p1 = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
-    a3_p2 = quick_spec 'a', 3 do |s| s.platform = unknown end
+    a2_p1   = a3_p2 = nil
+
+    spec_fetcher do |fetcher|
+              fetcher.spec 'a', 2
+      a2_p1 = fetcher.spec 'a', 2 do |s| s.platform = Gem::Platform.local end
+      a3_p2 = fetcher.spec 'a', 3 do |s| s.platform = unknown end
+    end
+
     v2 = v(2)
     v3 = v(3)
     source = Gem::Source.new @gem_repo
@@ -87,9 +205,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     ad = make_dep "a"
 
-    res = Gem::DependencyResolver.new([ad], s)
+    res = Gem::Resolver.new([ad], s)
 
-    assert_set [a2_p1], res.resolve
+    assert_resolves_to [a2_p1], res
   end
 
   def test_only_returns_spec_once
@@ -103,9 +221,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, b1, c1)
 
-    res = Gem::DependencyResolver.new([ad, bd], s)
+    res = Gem::Resolver.new([ad, bd], s)
 
-    assert_set [a1, b1, c1], res.resolve
+    assert_resolves_to [a1, b1, c1], res
   end
 
   def test_picks_lower_version_when_needed
@@ -120,17 +238,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, b1, c1, c2)
 
-    res = Gem::DependencyResolver.new([ad, bd], s)
-
-    assert_set [a1, b1, c1], res.resolve
+    res = Gem::Resolver.new([ad, bd], s)
 
-    cons = res.conflicts
-
-    assert_equal 1, cons.size
-    con = cons.first
-
-    assert_equal "c (= 1)", con.dependency.to_s
-    assert_equal "c-2", con.activated.full_name
+    assert_resolves_to [a1, b1, c1], res
   end
 
   def test_conflict_resolution_only_effects_correct_spec
@@ -148,17 +258,30 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, b1, d3, d4, c1, c2)
 
-    res = Gem::DependencyResolver.new([ad, bd], s)
+    res = Gem::Resolver.new([ad, bd], s)
+
+    assert_resolves_to [a1, b1, c1, d4], res
+  end
+
+  def test_backoff_higher_version_to_satisfy_dep
+    t3 = util_spec "railties", "3.2"
+    t4 = util_spec "railties", "4.0"
+
+    r3 = util_spec "rails", "3.2", "railties" => "= 3.2"
+    r4 = util_spec "rails", "4.0", "railties" => "= 4.0"
 
-    assert_set [a1, b1, c1, d4], res.resolve
+    rd = make_dep "rails", "3.2"
 
-    cons = res.conflicts
+    c3 = util_spec "coffee", "3.0", "railties" => "~> 3.0"
+    c4 = util_spec "coffee", "4.0", "railties" => "~> 4.0"
 
-    assert_equal 1, cons.size
-    con = cons.first
+    cd = make_dep "coffee"
 
-    assert_equal "c (= 1)", con.dependency.to_s
-    assert_equal "c-2", con.activated.full_name
+    s = set(t3, t4, r3, r4, c3, c4)
+
+    res = Gem::Resolver.new([rd, cd], s)
+
+    assert_resolves_to [r3, t3, c3], res
   end
 
   def test_raises_dependency_error
@@ -173,33 +296,31 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, b1, c1, c2)
 
-    r = Gem::DependencyResolver.new([ad, bd], s)
+    r = Gem::Resolver.new([ad, bd], s)
 
     e = assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
 
-    assert_equal "unable to resolve conflicting dependencies 'c (= 2)' and 'c (= 1)'", e.message
-
-    deps = [make_dep("c", "= 2"), make_dep("c", "= 1")]
+    deps = [make_dep("c", "= 1"), make_dep("c", "= 2")]
     assert_equal deps, e.conflicting_dependencies
 
     con = e.conflict
 
     act = con.activated
-    assert_equal "c-1", act.spec.full_name
+    assert_equal "c-2", act.spec.full_name
 
     parent = act.parent
-    assert_equal "a-1", parent.spec.full_name
+    assert_equal "b-1", parent.spec.full_name
 
     act = con.requester
-    assert_equal "b-1", act.spec.full_name
+    assert_equal "a-1", act.spec.full_name
   end
 
   def test_raises_when_a_gem_is_missing
     ad = make_dep "a"
 
-    r = Gem::DependencyResolver.new([ad], set)
+    r = Gem::Resolver.new([ad], set)
 
     e = assert_raises Gem::UnsatisfiableDepedencyError do
       r.resolve
@@ -216,7 +337,7 @@ class TestGemDependencyResolver < Gem::TestCase
 
     ad = make_dep "a", "= 3"
 
-    r = Gem::DependencyResolver.new([ad], set(a1))
+    r = Gem::Resolver.new([ad], set(a1))
 
     e = assert_raises Gem::UnsatisfiableDepedencyError do
       r.resolve
@@ -229,7 +350,7 @@ class TestGemDependencyResolver < Gem::TestCase
     a1 = util_spec "a", "1"
     ad = make_dep "a", "= 3"
 
-    r = Gem::DependencyResolver.new([ad], set(a1))
+    r = Gem::Resolver.new([ad], set(a1))
 
     e = assert_raises Gem::UnsatisfiableDepedencyError do
       r.resolve
@@ -246,7 +367,7 @@ class TestGemDependencyResolver < Gem::TestCase
 
     ad = make_dep "a", "= 1"
 
-    r = Gem::DependencyResolver.new([ad], set(a1))
+    r = Gem::Resolver.new([ad], set(a1))
 
     e = assert_raises Gem::UnsatisfiableDepedencyError do
       r.resolve
@@ -269,20 +390,24 @@ class TestGemDependencyResolver < Gem::TestCase
     ad = make_dep "a"
     bd = make_dep "b"
 
-    r = Gem::DependencyResolver.new([ad, bd], s)
+    r = Gem::Resolver.new([ad, bd], s)
 
-    e = assert_raises Gem::ImpossibleDependenciesError do
+    e = assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
 
-    assert_match "a-1 requires c (>= 2) but it conflicted", e.message
+    dependency = e.conflict.dependency
+
+    assert_equal 'a', dependency.name
+    assert_equal req('>= 0'), dependency.requirement
 
-    assert_equal "c (>= 2)", e.dependency.to_s
+    activated = e.conflict.activated
+    assert_equal 'c-1', activated.full_name
 
-    s, con = e.conflicts[0]
-    assert_equal "c-3", s.full_name
-    assert_equal "c (= 1)", con.dependency.to_s
-    assert_equal "b-1", con.requester.full_name
+    assert_equal dep('c', '= 1'), activated.request.dependency
+
+    assert_equal [dep('c', '>= 2'), dep('c', '= 1')],
+                 e.conflict.conflicting_dependencies
   end
 
   def test_keeps_resolving_after_seeing_satisfied_dep
@@ -295,9 +420,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, b1, c1)
 
-    r = Gem::DependencyResolver.new([ad, bd], s)
+    r = Gem::Resolver.new([ad, bd], s)
 
-    assert_set [a1, b1, c1], r.resolve
+    assert_resolves_to [a1, b1, c1], r
   end
 
   def test_common_rack_activation_scenario
@@ -314,15 +439,15 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(lib1, rails, ap, rack100, rack101)
 
-    r = Gem::DependencyResolver.new([d1, d2], s)
+    r = Gem::Resolver.new([d1, d2], s)
 
-    assert_set [rails, ap, rack101, lib1], r.resolve
+    assert_resolves_to [rails, ap, rack101, lib1], r
 
     # check it with the deps reverse too
 
-    r = Gem::DependencyResolver.new([d2, d1], s)
+    r = Gem::Resolver.new([d2, d1], s)
 
-    assert_set [lib1, rack101, rails, ap], r.resolve
+    assert_resolves_to [lib1, rack101, rails, ap], r
   end
 
   def test_backtracks_to_the_first_conflict
@@ -337,9 +462,9 @@ class TestGemDependencyResolver < Gem::TestCase
 
     s = set(a1, a2, a3, a4)
 
-    r = Gem::DependencyResolver.new([d1, d2, d3], s)
+    r = Gem::Resolver.new([d1, d2, d3], s)
 
-    assert_raises Gem::ImpossibleDependenciesError do
+    assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
   end
@@ -355,13 +480,49 @@ class TestGemDependencyResolver < Gem::TestCase
     a_dep = dep 'a', '~> 1.0'
     b_dep = dep 'b'
 
-    r = Gem::DependencyResolver.new [a_dep, b_dep], s
+    r = Gem::Resolver.new [a_dep, b_dep], s
 
     assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
   end
 
+  def test_resolve_bug_699
+    a1 = util_spec 'a', '1', 'b' => '= 2',
+                             'c' => '~> 1.0.3'
+
+    b1 = util_spec 'b', '2', 'c' => '~> 1.0'
+
+    c1 = util_spec 'c', '1.0.9'
+    c2 = util_spec 'c', '1.1.0'
+    c3 = util_spec 'c', '1.2.0'
+
+    s = set a1, b1, c1, c2, c3
+
+    a_dep = dep 'a', '= 1'
+
+    r = Gem::Resolver.new [a_dep], s
+
+    assert_resolves_to [a1, b1, c1], r
+  end
+
+  def test_resolve_rollback
+    a1 = util_spec 'a', 1
+    a2 = util_spec 'a', 2
+
+    b1 = util_spec 'b', 1, 'a' => '~> 1.0'
+    b2 = util_spec 'b', 2, 'a' => '~> 2.0'
+
+    s = set a1, a2, b1, b2
+
+    a_dep = dep 'a', '~> 1.0'
+    b_dep = dep 'b'
+
+    r = Gem::Resolver.new [a_dep, b_dep], s
+
+    assert_resolves_to [a1, b1], r
+  end
+
   # actionmailer 2.3.4
   # activemerchant 1.5.0
   # activesupport 2.3.5, 2.3.4
@@ -380,9 +541,9 @@ class TestGemDependencyResolver < Gem::TestCase
     d1 = make_dep "activemerchant"
     d2 = make_dep "actionmailer"
 
-    r = Gem::DependencyResolver.new([d1, d2], s)
+    r = Gem::Resolver.new([d1, d2], s)
 
-    assert_set [merch, mail, sup1], r.resolve
+    assert_resolves_to [merch, mail, sup1], r
   end
 
   def test_second_level_backout
@@ -398,17 +559,17 @@ class TestGemDependencyResolver < Gem::TestCase
     p1 = make_dep "b", "> 0"
     p2 = make_dep "d", "> 0"
 
-    r = Gem::DependencyResolver.new([p1, p2], s)
+    r = Gem::Resolver.new([p1, p2], s)
 
-    assert_set [b1, c1, d2], r.resolve
+    assert_resolves_to [b1, c1, d2], r
   end
 
   def test_select_local_platforms
-    r = Gem::DependencyResolver.new nil, nil
+    r = Gem::Resolver.new nil, nil
 
-    a1    = quick_spec 'a', 1
-    a1_p1 = quick_spec 'a', 1 do |s| s.platform = Gem::Platform.local end
-    a1_p2 = quick_spec 'a', 1 do |s| s.platform = 'unknown'           end
+    a1    = util_spec 'a', 1
+    a1_p1 = util_spec 'a', 1 do |s| s.platform = Gem::Platform.local end
+    a1_p2 = util_spec 'a', 1 do |s| s.platform = 'unknown'           end
 
     selected = r.select_local_platforms [a1, a1_p1, a1_p2]
 
@@ -422,7 +583,7 @@ class TestGemDependencyResolver < Gem::TestCase
 
     ad = make_dep "a", "= 1"
 
-    r = Gem::DependencyResolver.new([ad], set(a1))
+    r = Gem::Resolver.new([ad], set(a1))
 
     e = assert_raises Gem::UnsatisfiableDepedencyError do
       r.resolve