admin/brew
1
0
Fork 0
Code Issues Packages Projects Releases 6 Wiki Activity

Merge pull request #2207 from reitermarkus/spec-dependency_collector

Browse Source 
Convert DependencyCollector test to spec.
This commit is contained in:
Markus Reiter 2017-02-27 12:55:44 +01:00 committed by GitHub
commit 0dfe85df13
2 changed files with 137 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
Library/Homebrew/test/dependency_collector_spec.rb Normal file
View File

@ -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

148
Library/Homebrew/test/dependency_collector_test.rb
View File

@ -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