Merge pull request #2207 from reitermarkus/spec-dependency_collector

Convert DependencyCollector test to spec.

2 files changed, 137 insertions, 148 deletions

diff --git a/Library/Homebrew/test/dependency_collector_spec.rb b/Library/Homebrew/test/dependency_collector_spec.rb
new file mode 100644
index 000000000..82d117939
--- /dev/null
+++ b/Library/Homebrew/test/dependency_collector_spec.rb
@@ -0,0 +1,137 @@
+require "dependency_collector"
+
+RSpec::Matchers.alias_matcher :be_a_build_requirement, :be_build
+
+describe DependencyCollector do
+  def find_dependency(name)
+    subject.deps.find { |dep| dep.name == name }
+  end
+
+  def find_requirement(klass)
+    subject.requirements.find { |req| req.is_a? klass }
+  end
+
+  after(:each) do
+    described_class.clear_cache
+  end
+
+  describe "#add" do
+    specify "dependency creation" do
+      subject.add "foo" => :build
+      subject.add "bar" => ["--universal", :optional]
+      expect(find_dependency("foo")).to be_an_instance_of(Dependency)
+      expect(find_dependency("bar").tags.count).to eq(2)
+    end
+
+    it "returns the created dependency" do
+      expect(subject.add("foo")).to eq(Dependency.new("foo"))
+    end
+
+    specify "requirement creation" do
+      subject.add :x11
+      expect(find_requirement(X11Requirement)).to be_an_instance_of(X11Requirement)
+    end
+
+    it "deduplicates requirements" do
+      2.times { subject.add :x11 }
+      expect(subject.requirements.count).to eq(1)
+    end
+
+    specify "requirement tags" do
+      subject.add x11: "2.5.1"
+      subject.add xcode: :build
+      expect(find_requirement(X11Requirement).tags).to be_empty
+      expect(find_requirement(XcodeRequirement)).to be_a_build_requirement
+    end
+
+    specify "x11 without tag" do
+      subject.add :x11
+      expect(find_requirement(X11Requirement).tags).to be_empty
+    end
+
+    specify "x11 with minimum version" do
+      subject.add x11: "2.5.1"
+      expect(find_requirement(X11Requirement).min_version.to_s).to eq("2.5.1")
+    end
+
+    specify "x11 with tag" do
+      subject.add x11: :optional
+      expect(find_requirement(X11Requirement)).to be_optional
+    end
+
+    specify "x11 with minimum version and tag" do
+      subject.add x11: ["2.5.1", :optional]
+      dep = find_requirement(X11Requirement)
+      expect(dep.min_version.to_s).to eq("2.5.1")
+      expect(dep).to be_optional
+    end
+
+    specify "ant dependency" do
+      subject.add ant: :build
+      expect(find_dependency("ant")).to eq(Dependency.new("ant", [:build]))
+    end
+
+    it "doesn't mutate the dependency spec" do
+      spec = { "foo" => :optional }
+      copy = spec.dup
+      subject.add(spec)
+      expect(spec).to eq(copy)
+    end
+
+    it "creates a resource dependency from a '.git' URL" do
+      resource = Resource.new
+      resource.url("git://example.com/foo/bar.git")
+      expect(subject.add(resource)).to be_an_instance_of(GitRequirement)
+    end
+
+    it "creates a resource dependency from a '.7z' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.7z")
+      expect(subject.add(resource)).to eq(Dependency.new("p7zip", [:build]))
+    end
+
+    it "creates a resource dependency from a '.gz' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.tar.gz")
+      expect(subject.add(resource)).to be nil
+    end
+
+    it "creates a resource dependency from a '.lz' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.lz")
+      expect(subject.add(resource)).to eq(Dependency.new("lzip", [:build]))
+    end
+
+    it "creates a resource dependency from a '.lha' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.lha")
+      expect(subject.add(resource)).to eq(Dependency.new("lha", [:build]))
+    end
+
+    it "creates a resource dependency from a '.lzh' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.lzh")
+      expect(subject.add(resource)).to eq(Dependency.new("lha", [:build]))
+    end
+
+    it "creates a resource dependency from a '.rar' URL" do
+      resource = Resource.new
+      resource.url("http://example.com/foo.rar")
+      expect(subject.add(resource)).to eq(Dependency.new("unrar", [:build]))
+    end
+
+    it "raises a TypeError for unknown classes" do
+      expect { subject.add(Class.new) }.to raise_error(TypeError)
+    end
+
+    it "raises a TypeError for unknown Types" do
+      expect { subject.add(Object.new) }.to raise_error(TypeError)
+    end
+
+    it "raises a TypeError for a Resource with an unknown download strategy" do
+      resource = Resource.new
+      resource.download_strategy = Class.new
+      expect { subject.add(resource) }.to raise_error(TypeError)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/dependency_collector_test.rb b/Library/Homebrew/test/dependency_collector_test.rb
deleted file mode 100644
index c63d04637..000000000
--- a/Library/Homebrew/test/dependency_collector_test.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-require "testing_env"
-require "dependency_collector"
-
-class DependencyCollectorTests < Homebrew::TestCase
-  def find_dependency(name)
-    @d.deps.find { |dep| dep.name == name }
-  end
-
-  def find_requirement(klass)
-    @d.requirements.find { |req| req.is_a? klass }
-  end
-
-  def setup
-    super
-    @d = DependencyCollector.new
-  end
-
-  def teardown
-    DependencyCollector.clear_cache
-    super
-  end
-
-  def test_dependency_creation
-    @d.add "foo" => :build
-    @d.add "bar" => ["--universal", :optional]
-    assert_instance_of Dependency, find_dependency("foo")
-    assert_equal 2, find_dependency("bar").tags.length
-  end
-
-  def test_add_returns_created_dep
-    ret = @d.add "foo"
-    assert_equal Dependency.new("foo"), ret
-  end
-
-  def test_dependency_tags
-    assert_predicate Dependency.new("foo", [:build]), :build?
-    assert_predicate Dependency.new("foo", [:build, :optional]), :optional?
-    assert_includes Dependency.new("foo", ["universal"]).options, "--universal"
-    assert_empty Dependency.new("foo").tags
-  end
-
-  def test_requirement_creation
-    @d.add :x11
-    assert_instance_of X11Requirement, find_requirement(X11Requirement)
-  end
-
-  def test_no_duplicate_requirements
-    2.times { @d.add :x11 }
-    assert_equal 1, @d.requirements.count
-  end
-
-  def test_requirement_tags
-    @d.add x11: "2.5.1"
-    @d.add xcode: :build
-    assert_empty find_requirement(X11Requirement).tags
-    assert_predicate find_requirement(XcodeRequirement), :build?
-  end
-
-  def test_x11_no_tag
-    @d.add :x11
-    assert_empty find_requirement(X11Requirement).tags
-  end
-
-  def test_x11_min_version
-    @d.add x11: "2.5.1"
-    assert_equal "2.5.1", find_requirement(X11Requirement).min_version.to_s
-  end
-
-  def test_x11_tag
-    @d.add x11: :optional
-    assert_predicate find_requirement(X11Requirement), :optional?
-  end
-
-  def test_x11_min_version_and_tag
-    @d.add x11: ["2.5.1", :optional]
-    dep = find_requirement(X11Requirement)
-    assert_equal "2.5.1", dep.min_version.to_s
-    assert_predicate dep, :optional?
-  end
-
-  def test_ant_dep
-    @d.add ant: :build
-    assert_equal find_dependency("ant"), Dependency.new("ant", [:build])
-  end
-
-  def test_raises_typeerror_for_unknown_classes
-    assert_raises(TypeError) { @d.add(Class.new) }
-  end
-
-  def test_raises_typeerror_for_unknown_types
-    assert_raises(TypeError) { @d.add(Object.new) }
-  end
-
-  def test_does_not_mutate_dependency_spec
-    spec = { "foo" => :optional }
-    copy = spec.dup
-    @d.add(spec)
-    assert_equal copy, spec
-  end
-
-  def test_resource_dep_git_url
-    resource = Resource.new
-    resource.url("git://example.com/foo/bar.git")
-    assert_instance_of GitRequirement, @d.add(resource)
-  end
-
-  def test_resource_dep_7z_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.7z")
-    assert_equal Dependency.new("p7zip", [:build]), @d.add(resource)
-  end
-
-  def test_resource_dep_gzip_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.tar.gz")
-    assert_nil @d.add(resource)
-  end
-
-  def test_resource_dep_lz_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.lz")
-    assert_equal Dependency.new("lzip", [:build]), @d.add(resource)
-  end
-
-  def test_resource_dep_lha_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.lha")
-    assert_equal Dependency.new("lha", [:build]), @d.add(resource)
-  end
-
-  def test_resource_dep_lzh_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.lzh")
-    assert_equal Dependency.new("lha", [:build]), @d.add(resource)
-  end
-
-  def test_resource_dep_rar_url
-    resource = Resource.new
-    resource.url("http://example.com/foo.rar")
-    assert_equal Dependency.new("unrar", [:build]), @d.add(resource)
-  end
-
-  def test_resource_dep_raises_for_unknown_classes
-    resource = Resource.new
-    resource.download_strategy = Class.new
-    assert_raises(TypeError) { @d.add(resource) }
-  end
-end