solve 4.0.0 → 4.0.1

data/spec/unit/solve/graph_spec.rb

@@ -1,130 +0,0 @@
-require "spec_helper"
-
-describe Solve::Graph do
-  describe "#artifact?" do
-    it "returns true if the given Solve::Artifact is a member of the collection" do
-      subject.artifact("nginx", "1.0.0")
-      expect(subject).to have_artifact("nginx", "1.0.0")
-    end
-
-    it "returns false if the given Solve::Artifact is not a member of the collection" do
-      expect(subject).to_not have_artifact("apache", "1.0.0")
-      expect(subject).to_not have_artifact("nginx", "11.4.4")
-    end
-  end
-
-  describe "#find" do
-    before { subject.artifact("nginx", "1.0.0") }
-
-    it "returns an instance of artifact of the matching name and version" do
-      artifact = subject.find("nginx", "1.0.0")
-
-      expect(artifact).to be_a(Solve::Artifact)
-      expect(artifact.name).to eq("nginx")
-      expect(artifact.version.to_s).to eq("1.0.0")
-    end
-
-    it "returns nil when the artifact does not exist" do
-      expect(subject.find("notthere", "1.0.0")).to be_nil
-    end
-  end
-
-  describe "#artifact" do
-    let(:name)    { "nginx" }
-    let(:version) { "1.0.0" }
-
-    context "given the artifact of the given name and version does not exist" do
-      it "returns a Solve::Artifact" do
-        expect(subject.artifact(name, version)).to be_a(Solve::Artifact)
-      end
-
-      it "the artifact has the given name" do
-        artifact = subject.artifact(name, version)
-        expect(artifact.name).to eq(name)
-      end
-
-      it "the artifact has the given version" do
-        artifact = subject.artifact(name, version)
-        expect(artifact.version.to_s).to eq(version)
-      end
-
-      it "adds an artifact to the artifacts collection" do
-        subject.artifact(name, version)
-        expect(subject).to have_artifact(name, version)
-      end
-    end
-  end
-
-  describe "#artifacts" do
-    it "returns an array" do
-      expect(subject.artifacts).to be_a(Array)
-    end
-
-    it "returns an empty array if no artifacts have been accessed" do
-      expect(subject.artifacts).to be_empty
-    end
-
-    it "returns an array containing an artifact if one was accessed" do
-      subject.artifact("nginx", "1.0.0")
-      expect(subject.artifacts.size).to eq(1)
-    end
-  end
-
-  describe "#versions" do
-    before do
-      subject.artifact("nginx", "1.0.0")
-      subject.artifact("nginx", "2.0.0")
-      subject.artifact("nginx", "3.0.0")
-      subject.artifact("nginx", "4.0.0")
-
-      subject.artifact("other", "1.0.0")
-    end
-
-    it "returns all the artifacts matching the given name" do
-      expect(subject.versions("nginx").size).to eq(4)
-    end
-
-    it "does not satisfy constraints if it is the default" do
-      constraint = Semverse::Constraint.new(Semverse::DEFAULT_CONSTRAINT.to_s)
-      expect(constraint).to_not receive(:satisfies?)
-      subject.versions("nginx")
-    end
-
-    it "returns only matching constraints if one is given" do
-      expect(subject.versions("nginx", ">= 3.0.0").size).to eq(2)
-    end
-  end
-
-  describe "==" do
-    def make_graph
-      graph = Solve::Graph.new
-      graph.artifact("A" , "1.0.0").depends("B", "1.0.0")
-      graph.artifact("A" , "2.0.0").depends("C", "1.0.0")
-      graph
-    end
-
-    subject { make_graph }
-
-    it "returns false if other isn't a Solve::Graph" do
-      expect(subject).to_not eq("chicken")
-    end
-
-    it "returns true if the other is the same" do
-      expect(subject).to eq(make_graph)
-    end
-
-    it "returns false if the other has the same artifacts but different dependencies" do
-      other = make_graph
-      other.artifact("A", "1.0.0").depends("D", "1.0.0")
-
-      expect(subject).to_not eq(other)
-    end
-
-    it "returns false if the other has the same dependencies but different artifacts" do
-      other = make_graph
-      other.artifact("E", "1.0.0")
-
-      expect(subject).to_not eq(other)
-    end
-  end
-end

data/spec/unit/solve/ruby_solver_spec.rb

@@ -1,165 +0,0 @@
-require "spec_helper"
-
-describe Solve::RubySolver do
-  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
-
-      it "is a no-op" do
-        described_class.activate
-      end
-
-    end
-  end
-
-  let(:graph) { double(Solve::Graph) }
-  let(:demands) { [["mysql"], ["nginx"]] }
-  subject(:solver) { described_class.new(graph, demands, dependency_source: "Berksfile") }
-
-  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 molinillo 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
-        expect(error).to be_a_kind_of(Solve::Errors::NoSolutionError)
-        expected_error = <<-ERROR_MESSAGE
-Unable to satisfy the following requirements:
-
-- `Z (>= 0.0.0)` required by `Berksfile`
-ERROR_MESSAGE
-        expect(error.to_s).to eq(expected_error)
-      end
-    end
-
-    context "and molinillo 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
-        expect(error).to be_a_kind_of(Solve::Errors::NoSolutionError)
-        expected_error = <<-ERROR_MESSAGE
-Unable to satisfy the following requirements:
-
-- `A (> 1.0.0)` required by `Berksfile`
-ERROR_MESSAGE
-        expect(error.to_s).to eq(expected_error)
-      end
-    end
-
-    context "and molinillo 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
-        expect(error).to be_a_kind_of(Solve::Errors::NoSolutionError)
-        expected_error = <<-ERROR_MESSAGE
-Unable to satisfy the following requirements:
-
-- `D (= 1.0.0)` required by `B-1.0.0`
-- `D (= 2.0.0)` required by `C-1.0.0`
-ERROR_MESSAGE
-        expect(error.to_s).to eq(expected_error)
-      end
-    end
-  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

data/spec/unit/solve/solver/serializer_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-require "solve/ruby_solver"
-
-describe Solve::Solver::Serializer do
-
-  let(:graph) do
-    Solve::Graph.new.tap do |g|
-      g.artifact("A", "1.0.0").depends("B", "1.0.0")
-      g.artifact("B", "1.0.0").depends("C", "1.0.0")
-      g.artifact("C", "1.0.0")
-    end
-  end
-
-  let(:demands) { [["A", "1.0.0"]] }
-
-  let(:serializer) { Solve::Solver::Serializer.new }
-
-  it "deserializes a serialized problem to an equivalent problem" do
-    problem = Solve::Problem.new(graph, demands)
-    serialized = serializer.serialize(problem)
-    deserialized = serializer.deserialize(serialized)
-
-    problem.graph.should eql(deserialized.graph)
-    problem.demands.should eql(deserialized.demands)
-  end
-
-  it "creates a problem from a solver" do
-    solver = Solve::RubySolver.new(graph, demands)
-    problem = Solve::Problem.from_solver(solver)
-    expect(problem.demands).to eq([["A", "= 1.0.0"]])
-    expect(problem.graph).to eq(graph)
-  end
-end

data/spec/unit/solve_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Solve do
-  describe "ClassMethods" do
-    subject { Solve }
-
-    describe "#it" do
-      it "returns nil if a solution does not exist" do
-        skip
-      end
-    end
-
-    describe "#it!" do
-      it "raises NoSolutionError if a solution does not exist" do
-        skip
-      end
-    end
-  end
-end