1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
require "dependency"
describe Dependency do
alias_matcher :be_a_build_dependency, :be_build
alias_matcher :be_a_runtime_dependency, :be_run
describe "::new" do
it "accepts a single tag" do
dep = described_class.new("foo", %w[bar])
expect(dep.tags).to eq(%w[bar])
end
it "accepts multiple tags" do
dep = described_class.new("foo", %w[bar baz])
expect(dep.tags.sort).to eq(%w[bar baz].sort)
end
it "preserves symbol tags" do
dep = described_class.new("foo", [:build])
expect(dep.tags).to eq([:build])
end
it "accepts symbol and string tags" do
dep = described_class.new("foo", [:build, "bar"])
expect(dep.tags).to eq([:build, "bar"])
end
end
describe "::merge_repeats" do
it "merges duplicate dependencies" do
dep = described_class.new("foo", [:build], nil, "foo")
dep2 = described_class.new("foo", ["bar"], nil, "foo2")
dep3 = described_class.new("xyz", ["abc"], nil, "foo")
merged = described_class.merge_repeats([dep, dep2, dep3])
expect(merged.count).to eq(2)
expect(merged.first).to be_a described_class
foo_named_dep = merged.find { |d| d.name == "foo" }
expect(foo_named_dep.tags).to eq(["bar"])
expect(foo_named_dep.option_names).to include("foo")
expect(foo_named_dep.option_names).to include("foo2")
xyz_named_dep = merged.find { |d| d.name == "xyz" }
expect(xyz_named_dep.tags).to eq(["abc"])
expect(xyz_named_dep.option_names).to include("foo")
expect(xyz_named_dep.option_names).not_to include("foo2")
end
it "merges necessity tags" do
required_dep = described_class.new("foo")
recommended_dep = described_class.new("foo", [:recommended])
optional_dep = described_class.new("foo", [:optional])
deps = described_class.merge_repeats([required_dep, recommended_dep])
expect(deps.count).to eq(1)
expect(deps.first).to be_required
expect(deps.first).not_to be_recommended
expect(deps.first).not_to be_optional
deps = described_class.merge_repeats([required_dep, optional_dep])
expect(deps.count).to eq(1)
expect(deps.first).to be_required
expect(deps.first).not_to be_recommended
expect(deps.first).not_to be_optional
deps = described_class.merge_repeats([recommended_dep, optional_dep])
expect(deps.count).to eq(1)
expect(deps.first).not_to be_required
expect(deps.first).to be_recommended
expect(deps.first).not_to be_optional
end
it "merges temporality tags" do
normal_dep = described_class.new("foo")
build_dep = described_class.new("foo", [:build])
run_dep = described_class.new("foo", [:run])
deps = described_class.merge_repeats([normal_dep, build_dep])
expect(deps.count).to eq(1)
expect(deps.first).not_to be_a_build_dependency
expect(deps.first).not_to be_a_runtime_dependency
deps = described_class.merge_repeats([normal_dep, run_dep])
expect(deps.count).to eq(1)
expect(deps.first).not_to be_a_build_dependency
expect(deps.first).not_to be_a_runtime_dependency
deps = described_class.merge_repeats([build_dep, run_dep])
expect(deps.count).to eq(1)
expect(deps.first).not_to be_a_build_dependency
expect(deps.first).not_to be_a_runtime_dependency
end
end
specify "equality" do
foo1 = described_class.new("foo")
foo2 = described_class.new("foo")
expect(foo1).to eq(foo2)
expect(foo1).to eql(foo2)
bar = described_class.new("bar")
expect(foo1).not_to eq(bar)
expect(foo1).not_to eql(bar)
foo3 = described_class.new("foo", [:build])
expect(foo1).not_to eq(foo3)
expect(foo1).not_to eql(foo3)
end
end
describe TapDependency do
subject { described_class.new("foo/bar/dog") }
specify "#tap" do
expect(subject.tap).to eq(Tap.new("foo", "bar"))
end
specify "#option_names" do
expect(subject.option_names).to eq(%w[dog])
end
end
|
