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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
# frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Protection::CreateRuleService, '#execute', feature_category: :environment_management do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }
let(:service) { described_class.new(project: project, current_user: current_user, params: params) }
let(:current_user) { maintainer }
let(:params) { attributes_for(:package_protection_rule) }
subject { service.execute }
shared_examples 'a successful service response' do
let(:package_protection_rule_count_expected) { 1 }
it { is_expected.to be_success }
it do
is_expected.to have_attributes(
payload: include(
package_protection_rule: be_a(Packages::Protection::Rule)
)
)
end
it { expect(subject.payload).to include(package_protection_rule: be_a(Packages::Protection::Rule)) }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(1)
expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
expect(Packages::Protection::Rule.where(project: project,
package_name_pattern: params[:package_name_pattern])).to exist
end
end
shared_examples 'an erroneous service response' do
let(:package_protection_rule_count_expected) { 0 }
it { is_expected.to be_error }
it { is_expected.to have_attributes(payload: include(package_protection_rule: nil)) }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(0)
expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
expect(Packages::Protection::Rule.where(project: project,
package_name_pattern: params[:package_name_pattern])).not_to exist
end
end
context 'without existing PackageProtectionRules' do
context 'when fields are valid' do
it_behaves_like 'a successful service response'
end
context 'when fields are invalid' do
let(:params) do
{
package_name_pattern: '',
package_type: 'unknown_package_type',
push_protected_up_to_access_level: 1000
}
end
it_behaves_like 'an erroneous service response'
end
end
context 'with existing PackageProtectionRule' do
let_it_be(:existing_package_protection_rule) { create(:package_protection_rule, project: project) }
context 'when package name pattern is slightly different' do
let(:params) do
attributes_for(
:package_protection_rule,
# The field `package_name_pattern` is unique; this is why we change the value in a minimum way
package_name_pattern: "#{existing_package_protection_rule.package_name_pattern}-unique",
package_type: existing_package_protection_rule.package_type,
push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
)
end
it_behaves_like 'a successful service response' do
let(:package_protection_rule_count_expected) { 2 }
end
end
context 'when field `package_name_pattern` is taken' do
let(:params) do
attributes_for(
:package_protection_rule,
package_name_pattern: existing_package_protection_rule.package_name_pattern,
package_type: existing_package_protection_rule.package_type,
push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
)
end
it { is_expected.to be_error }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(0)
expect(Packages::Protection::Rule.where(project: project).count).to eq 1
expect(
Packages::Protection::Rule.where(
project: project,
package_name_pattern: params[:package_name_pattern]
)
).to exist
end
end
end
context 'when disallowed params are passed' do
let(:params) do
attributes_for(:package_protection_rule)
.merge(
project_id: 1,
unsupported_param: 'unsupported_param_value'
)
end
it_behaves_like 'a successful service response'
end
context 'with forbidden user access level (project developer role)' do
# Because of the access level hierarchy, we can assume that
# other access levels below developer role will also not be able to
# create package protection rules.
let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
let(:current_user) { developer }
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes(message: match(/Unauthorized/)) }
end
end
|
