solve 3.1.1 → 4.0.4

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-require 'bundler'
-require 'spork'
-
-Spork.prefork do
-  require 'rspec'
-
-  APP_ROOT = File.expand_path('../../', __FILE__)
-
-  Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
-
-  RSpec.configure do |config|
-    config.mock_with :rspec
-    config.treat_symbols_as_metadata_keys_with_true_values = true
-    config.filter_run focus: true
-    config.run_all_when_everything_filtered = true
-
-    # Run specs in a random order
-    config.order = :random
-  end
-end
-
-Spork.each_run do
-  require 'solve'
-end

data/spec/unit/solve/artifact_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-describe Solve::Artifact do
-  let(:graph) do
-    package = double('package')
-    package_version = double('package_version')
-    package_version.stub(:dependencies).and_return([])
-    package.stub(:add_version).and_return(package_version)
-    double('graph', dep_graph: double('dep_graph', package: package))
-  end
-
-  let(:name) { "league" }
-  let(:version) { "1.0.0" }
-  subject { Solve::Artifact.new(graph, name, version) }
-
-  describe "equality" do
-    context "given an artifact with the same name and version" do
-      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
-      let(:two) { Solve::Artifact.new(graph, "riot", "1.0.0") }
-
-      it "is equal" do
-        expect(one).to eq(two)
-      end
-    end
-
-    context "given an artifact with the same name but different version" do
-      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
-      let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
-
-      it "is not equal" do
-        expect(one).to_not eq(two)
-      end
-    end
-
-    context "given an artifact with the same version but different name" do
-      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
-      let(:two) { Solve::Artifact.new(graph, "league", "1.0.0") }
-
-      it "is not equal" do
-        expect(one).to_not eq(two)
-      end
-    end
-  end
-
-  describe "sorting" do
-    let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
-    let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
-    let(:three) { Solve::Artifact.new(graph, "riot", "3.0.0") }
-
-    let(:artifacts) do
-      [
-        one,
-        two,
-        three
-      ].shuffle
-    end
-
-    it "orders artifacts by their version number" do
-      sorted = artifacts.sort
-
-      expect(sorted[0]).to eq(one)
-      expect(sorted[1]).to eq(two)
-      expect(sorted[2]).to eq(three)
-    end
-  end
-
-  describe "#dependency?" do
-    before { subject.depends("nginx", "1.0.0") }
-
-    it "returns false when the dependency does not exist" do
-      expect(subject).to have_dependency("nginx", "1.0.0")
-    end
-
-    it "returns true when the dependendency exists" do
-      expect(subject).to_not have_dependency("apache2", "2.0.0")
-    end
-  end
-
-  describe "#dependency" do
-    before { subject.depends("nginx", "~> 1.2.3") }
-
-    it "returns an instance of Solve::Dependency matching the given name and constraint" do
-      dependency = subject.dependency("nginx", "~> 1.2.3")
-
-      expect(dependency).to be_a(Solve::Dependency)
-      expect(dependency.name).to eq("nginx")
-      expect(dependency.constraint.to_s).to eq("~> 1.2.3")
-    end
-  end
-
-  describe "#dependencies" do
-    it "returns an array" do
-      expect(subject.dependencies).to be_a(Array)
-    end
-
-    it "returns an empty array if no dependencies have been accessed" do
-      expect(subject.dependencies).to be_empty
-    end
-
-    it "returns all dependencies" do
-      subject.depends("nginx", "1.0.0")
-      subject.depends("nginx", "~> 2.0.0")
-
-      expect(subject.dependencies.size).to eq(2)
-    end
-  end
-
-  describe "#depends" do
-    context "given a name and constraint argument" do
-      let(:name) { "nginx" }
-      let(:constraint) { "~> 1.0.0" }
-
-      context "given the dependency of the given name and constraint does not exist" do
-        it "returns a Solve::Artifact" do
-          expect(subject.depends(name, constraint)).to be_a(Solve::Artifact)
-        end
-
-        it "adds a dependency with the given name and constraint to the list of dependencies" do
-          subject.depends(name, constraint)
-
-          expect(subject.dependencies.size).to eq(1)
-          expect(subject.dependencies.first.name).to eq(name)
-          expect(subject.dependencies.first.constraint.to_s).to eq(constraint)
-        end
-      end
-    end
-
-    context "given only a name argument" do
-      it "adds a dependency with a all constraint (>= 0.0.0)" do
-        subject.depends("nginx")
-
-        expect(subject.dependencies.size).to eq(1)
-        expect(subject.dependencies.first.constraint.to_s).to eq(">= 0.0.0")
-      end
-    end
-  end
-end

data/spec/unit/solve/demand_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Solve::Demand do
-  let(:solver) { double('solver') }
-  let(:name) { "league" }
-
-  describe "#initialize" do
-    it "accepts a string for the constraint parameter" do
-      demand = Solve::Demand.new(solver, name, "= 0.0.1")
-      expect(demand.constraint.to_s).to eq("= 0.0.1")
-    end
-
-    it "accepts a Semverse::Constraint for the constraint parameter" do
-      constraint = Semverse::Constraint.new("= 0.0.1")
-      demand = Solve::Demand.new(solver, name, constraint)
-
-      expect(demand.constraint).to eq(constraint)
-    end
-
-    context "when no value for 'constraint' is given" do
-      it "uses a default of >= 0.0.0" do
-        demand = Solve::Demand.new(solver, name)
-
-        expect(demand.constraint.operator).to eq(">=")
-        expect(demand.constraint.version.to_s).to eq("0.0.0")
-      end
-    end
-  end
-
-  let(:constraint) { "~> 1.0.0" }
-  subject { Solve::Demand.new(solver, name, constraint) }
-
-  describe "equality" do
-    it "returns true when other is a Solve::Demand with the same name and constriant" do
-      other = Solve::Demand.new(solver, name, constraint)
-      expect(subject).to eq(other)
-    end
-
-    it "returns false when other isn't a Solve::Demand" do
-      expect(subject).to_not eq("chicken")
-    end
-
-    it "returns false when other is a Solve::Demand with the same name but a different constraint" do
-      other = Solve::Demand.new(solver, name, "< 3.4.5")
-      expect(subject).to_not eq(other)
-    end
-
-    it "returns false when other is a Solve::Demand with the same constraint but a different name" do
-      other = Solve::Demand.new(solver, "chicken", constraint)
-      expect(subject).to_not eq(other)
-    end
-  end
-end

data/spec/unit/solve/dependency_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Solve::Dependency do
-  describe "#initialize" do
-    it "uses a default of >= 0.0.0" do
-      dep = Solve::Dependency.new(double("artifact"), "ntp")
-
-      expect(dep.constraint.operator).to eq(">=")
-      expect(dep.constraint.version.to_s).to eq("0.0.0")
-    end
-  end
-
-  let(:artifact) { double('artifact') }
-  let(:name) { 'nginx' }
-  let(:constraint) { "~> 0.0.1" }
-
-  subject { Solve::Dependency.new(artifact, name, constraint) }
-
-  describe "#==" do
-    it "returns true if the other object is an instance of Solve::Dependency with the same constraint and artifact" do
-      other = Solve::Dependency.new(artifact, name, constraint)
-      expect(subject).to eq(other)
-    end
-  end
-end

data/spec/unit/solve/gecode_solver_spec.rb

@@ -1,206 +0,0 @@
-require 'spec_helper'
-
-require 'solve/gecode_solver'
-
-describe Solve::GecodeSolver, :gecode do
-
-  before(:all) do
-    described_class.activate
-  end
-
-  describe "ClassMethods" do
-    describe "::timeout" do
-      subject { described_class.timeout }
-
-      it "returns 30,000 by default" do
-        expect(subject).to eql(30_000)
-      end
-
-      context "when the SOLVE_TIMEOUT env variable is set" do
-        before { ENV.stub(:[]).with("SOLVE_TIMEOUT") { "30" } }
-
-        it "returns the value multiplied by a thousand" do
-          expect(subject).to eql(30_000)
-        end
-      end
-    end
-
-    describe "::activate" do
-
-      context "when dep_selector is not installed" do
-
-        it "raises EngineNotAvailable" do
-          exception = LoadError.new("cannot load such file -- dep_selector")
-          allow(described_class).to receive(:require).with("dep_selector").and_raise(exception)
-          expect { described_class.activate }.to raise_error(Solve::Errors::EngineNotAvailable)
-        end
-
-      end
-
-      context "when dep_selector is installed" do
-
-        it "requires dep_selector" do
-          expect(described_class).to receive(:require).with("dep_selector").and_call_original
-          described_class.activate
-        end
-      end
-
-    end
-  end
-
-  let(:graph) { double(Solve::Graph) }
-  let(:demands) { [["mysql"], ["nginx"]] }
-  subject(:solver) { described_class.new(graph, demands) }
-
-  it "has a list of demands as ruby literals" do
-    solver.demands_array.should == demands
-  end
-
-  it "has a list of demands as model objects" do
-    expected = [
-      Solve::Demand.new(solver, "mysql"),
-      Solve::Demand.new(solver, "nginx")
-    ]
-    solver.demands.should == expected
-  end
-
-  it "has a graph" do
-    solver.graph.should == graph
-  end
-
-  describe "when the constraints are solvable" do
-    let(:graph) do
-      graph = Solve::Graph.new
-      graph.artifact("A", "1.0.0")
-      graph.artifact("B", "1.0.0").depends("A")
-      graph
-    end
-
-    let(:demands) { [["A"], ["B"]] }
-
-    it "gives the solution as a Hash" do
-      solver.resolve.should == {"A"=>"1.0.0", "B"=>"1.0.0"}
-    end
-
-    it "gives the solution in sorted form" do
-      solver.resolve(sorted: true).should == [["A", "1.0.0"], ["B", "1.0.0"]]
-    end
-  end
-
-  describe "when the constraints are not solvable" do
-    let(:error) do
-      begin
-        solver.resolve
-      rescue => e
-        e
-      else
-        raise "Expected resolve to cause an error"
-      end
-    end
-
-    context "and dep-selector identifies missing artifacts" do
-      let(:graph) do
-        graph = Solve::Graph.new
-        graph.artifact("A", "1.0.0")
-        graph
-      end
-
-      let(:demands) { [ ["Z"] ] }
-
-      it "raises an error detailing the missing artifacts" do
-        error.to_s.should include("Missing artifacts: Z")
-      end
-    end
-
-    context "and dep-selector identifies constraints that exclude all known versions" do
-      let(:graph) do
-        graph = Solve::Graph.new
-        graph.artifact("A", "1.0.0")
-        graph
-      end
-
-      let(:demands) { [ ["A", "> 1.0.0"] ] }
-
-      it "raises an error detailing the missing artifacts" do
-        error.to_s.should include("Required artifacts do not exist at the desired version")
-        error.to_s.should include("Constraints that match no available version: (A > 1.0.0)")
-      end
-    end
-
-    context "and dep-selector identifies dependency conflicts" do
-      let(:graph) do
-        graph = Solve::Graph.new
-        graph.artifact("A", "1.0.0").depends("B").depends("C")
-        graph.artifact("B", "1.0.0").depends("D", "= 1.0.0")
-        graph.artifact("C", "1.0.0").depends("D", "= 2.0.0")
-        graph.artifact("D", "1.0.0")
-        graph.artifact("D", "2.0.0")
-        graph
-      end
-
-      let(:demands) { [ [ "A" ] ] }
-
-      it "raises an error detailing the missing artifacts" do
-        error.to_s.should include("Demand that cannot be met: (A >= 0.0.0)")
-        error.to_s.should include("Artifacts for which there are conflicting dependencies: D = 1.0.0 -> []")
-      end
-    end
-
-    context "and dep-selector times out looking for a solution" do
-      let(:selector) { double(DepSelector::Selector) }
-
-      before do
-        graph.stub(:artifacts).and_return([])
-        DepSelector::Selector.stub(:new).and_return(selector)
-        selector.stub(:find_solution).and_raise(DepSelector::Exceptions::TimeBoundExceeded)
-      end
-
-      it "raises an error explaining no solution could be found" do
-        error.to_s.should include("The dependency constraints could not be solved in the time allotted.")
-      end
-    end
-
-    context "and dep-selector times out looking for dependency conflicts" do
-      let(:selector) { double(DepSelector::Selector) }
-
-      before do
-        graph.stub(:artifacts).and_return([])
-        DepSelector::Selector.stub(:new).and_return(selector)
-        selector.stub(:find_solution).and_raise(DepSelector::Exceptions::TimeBoundExceededNoSolution)
-      end
-
-      it "raises a NoSolutionCauseUnknown error to indicate that no debug info was generated" do
-        error.should be_a_kind_of(Solve::Errors::NoSolutionCauseUnknown)
-      end
-
-      it "raises an error explaining that no solution exists but the cause could not be determined" do
-        error.to_s.should include("There is a dependency conflict, but the solver could not determine the precise cause in the time allotted.")
-      end
-    end
-  end
-
-  describe "finding unsatisfiable demands" do
-    it "partitions demands into satisfiable and not satisfiable"
-  end
-
-  describe "supporting Serializer interface" do
-    let(:serializer) { Solve::Solver::Serializer.new }
-
-    before do
-      graph.stub(:artifacts).and_return([])
-    end
-
-    it "implements the required interface" do
-      problem = Solve::Problem.from_solver(solver)
-      json_string = serializer.serialize(problem)
-      problem_data = JSON.parse(json_string)
-      expected_demands = [
-        {"name" => "mysql", "constraint" => ">= 0.0.0"},
-        {"name" => "nginx", "constraint" => ">= 0.0.0"}
-      ]
-
-      problem_data["demands"].should =~ expected_demands
-    end
-  end
-end
-