@Test
public void return_project_settings() {
ComponentDto project = db.components().insertPrivateProject();
- db.properties().insertProperties(null, project.name(),
+ db.properties().insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("1").setValue("val1"),
newComponentPropertyDto(project).setKey("2").setValue("val2"),
newComponentPropertyDto(project).setKey("3").setValue("val3"));
public void project_settings_override_global_settings() {
settings.setProperty("key", "value");
ComponentDto project = db.components().insertPrivateProject();
- db.properties().insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("key").setValue("value2"));
+ db.properties().insertProperties(null, project.name(), project.qualifier(),
+ newComponentPropertyDto(project).setKey("key").setValue("value2"));
Configuration projectConfig = underTest.newProjectConfiguration(project.getDbKey(), new DefaultBranchImpl());
}
private void insertProjectProperty(ComponentDto project, String propertyKey, String propertyValue) {
- db.properties().insertProperties(null, project.name(),
+ db.properties().insertProperties(null, project.name(), project.qualifier(),
new PropertyDto().setKey(propertyKey).setValue(propertyValue).setComponentUuid(project.uuid()));
}
}
@Override
public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin,
- @Nullable String projectName) {
+ @Nullable String projectName, @Nullable String qualifier) {
// do nothing
}
}
@Override
- public void deleteProjectProperty(String key, String projectUuid, String projectName) {
+ public void deleteProjectProperty(String key, String projectUuid, String projectName, String qualifier) {
// do nothing
}
@Override
- public void deleteProjectProperty(String key, String projectUuid, DbSession session, String projectName) {
+ public void deleteProjectProperty(DbSession session, String key, String projectUuid, String projectName, String qualifier) {
// do nothing
}
private void insertProperty(String key, String value) {
PropertyDto dto = new PropertyDto().setKey(key).setValue(value);
- db.getDbClient().propertiesDao().saveProperty(db.getSession(), dto, null, null);
+ db.getDbClient().propertiesDao().saveProperty(db.getSession(), dto, null, null, null);
db.commit();
}
@Test
public void insertProperty() {
- underTest.saveProperty(dbSession, propertyDto, null, null);
+ underTest.saveProperty(dbSession, propertyDto, null, null, null);
assertNoInteraction();
}
@Test
public void deleteProjectProperty() {
- underTest.deleteProjectProperty(null, null, null);
+ underTest.deleteProjectProperty(null, null, null, null);
assertNoInteraction();
@Test
public void deleteProjectProperty1() {
- underTest.deleteProjectProperty(null, null, dbSession, null);
+ underTest.deleteProjectProperty(dbSession, null, null, null, null);
assertNoInteraction();
*/
package org.sonar.db.audit.model;
-public class ComponentKeyNewValue implements NewValue{
+public class ComponentKeyNewValue extends NewValue{
private final String componentUuid;
private final String oldKey;
import javax.annotation.Nullable;
import org.apache.commons.lang.ObjectUtils;
-import static org.sonar.api.resources.Qualifiers.APP;
-import static org.sonar.api.resources.Qualifiers.PROJECT;
-import static org.sonar.api.resources.Qualifiers.VIEW;
-
-public class ComponentNewValue implements NewValue {
+public class ComponentNewValue extends NewValue {
private String componentUuid;
private String componentName;
private String key;
private Boolean isPrivate;
private Boolean isEnabled;
- private String prefix;
+ private String qualifier;
public ComponentNewValue(String componentUuid, String name, String key, @Nullable String qualifier) {
this.componentUuid = componentUuid;
this.componentName = name;
this.key = key;
- this.generateComponentPrefix(qualifier);
+ this.qualifier = getQualifier(qualifier);
}
public ComponentNewValue(String rootComponentUuid, boolean isPrivate, @Nullable String qualifier) {
this.rootComponentUuid = rootComponentUuid;
this.isPrivate = isPrivate;
- this.generateComponentPrefix(qualifier);
+ this.qualifier = getQualifier(qualifier);
}
public ComponentNewValue(String componentUuid, String name, boolean isPrivate, String qualifier) {
this.componentUuid = componentUuid;
this.componentName = name;
this.isPrivate = isPrivate;
- this.generateComponentPrefix(qualifier);
+ this.qualifier = this.getQualifier(qualifier);
}
public ComponentNewValue(String uuid, String name, String key, boolean enabled, String path, @Nullable String qualifier) {
this.isEnabled = enabled;
this.path = path;
this.key = key;
- this.generateComponentPrefix(qualifier);
+ this.qualifier = getQualifier(qualifier);
}
public ComponentNewValue(String uuid, boolean isPrivate, String name, String key, @Nullable String description, @Nullable String qualifier) {
this.componentName = name;
this.key = key;
this.description = description;
- this.generateComponentPrefix(qualifier);
+ this.qualifier = getQualifier(qualifier);
}
public String getComponentUuid() {
return isPrivate;
}
- private void generateComponentPrefix(String qualifier) {
- if (qualifier == null) {
- this.prefix = "component";
- return ;
- }
- switch (qualifier) {
- case VIEW:
- this.prefix = "portfolio";
- break;
- case APP:
- this.prefix = "application";
- break;
- case PROJECT:
- this.prefix = "project";
- break;
- default:
- this.prefix = "component";
- break;
- }
+ public String getQualifier() {
+ return qualifier;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("{");
- addField(sb, "\"" + this.prefix + "Uuid\": ", this.componentUuid, true);
+ addField(sb, "\"componentUuid\": ", this.componentUuid, true);
addField(sb, "\"rootComponentUuid\": ", this.rootComponentUuid, true);
- addField(sb, "\"" + this.prefix + "Name\": ", this.componentName, true);
+ addField(sb, "\"componentName\": ", this.componentName, true);
+ addField(sb, "\"qualifier\": ", this.qualifier, true);
addField(sb, "\"description\": ", this.description, true);
addField(sb, "\"key\": ", this.key, true);
addField(sb, "\"path\": ", this.path, true);
import org.sonar.db.alm.setting.ProjectAlmSettingDto;
import org.sonar.db.project.ProjectDto;
-public class DevOpsPlatformSettingNewValue implements NewValue {
+public class DevOpsPlatformSettingNewValue extends NewValue {
@Nullable
private String devOpsPlatformSettingUuid;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-public class LicenseNewValue implements NewValue {
+public class LicenseNewValue extends NewValue {
@Nullable
private String edition;
*/
package org.sonar.db.audit.model;
+import javax.annotation.Nullable;
+
import static com.google.common.base.Strings.isNullOrEmpty;
+import static org.sonar.api.resources.Qualifiers.APP;
+import static org.sonar.api.resources.Qualifiers.PROJECT;
+import static org.sonar.api.resources.Qualifiers.VIEW;
-public interface NewValue {
+public abstract class NewValue {
- default void addField(StringBuilder sb, String field, String value, boolean isString) {
+ protected void addField(StringBuilder sb, String field, String value, boolean isString) {
if (!isNullOrEmpty(value)) {
sb.append(field);
addQuote(sb, isString);
}
}
- default void endString(StringBuilder sb) {
+ protected void endString(StringBuilder sb) {
int length = sb.length();
if(sb.length() > 1) {
sb.delete(length - 2, length - 1);
sb.append("\"");
}
}
+
+ protected String getQualifier(@Nullable String qualifier) {
+ if (qualifier == null) {
+ return null;
+ }
+ switch (qualifier) {
+ case VIEW:
+ return "portfolio";
+ case APP:
+ return "application";
+ case PROJECT:
+ return "project";
+ default:
+ return null;
+ }
+ }
+
+ @Override
+ public abstract String toString();
}
import org.sonar.db.permission.GroupPermissionDto;
import org.sonar.db.permission.UserPermissionDto;
-public class PermissionNewValue implements NewValue {
+public class PermissionNewValue extends NewValue {
@Nullable
private String permissionUuid;
private String userUuid;
@Nullable
- private String projectUuid;
+ private String componentUuid;
@Nullable
- private String projectName;
+ private String componentName;
@Nullable
private String role;
- public PermissionNewValue(GroupPermissionDto groupPermissionDto) {
+ @Nullable
+ private String qualifier;
+
+ public PermissionNewValue(GroupPermissionDto groupPermissionDto, @Nullable String componentName, @Nullable String qualifier) {
this.permissionUuid = groupPermissionDto.getUuid();
this.role = groupPermissionDto.getRole();
this.groupUuid = groupPermissionDto.getGroupUuid();
this.groupName = groupPermissionDto.getGroupName();
- this.projectUuid = groupPermissionDto.getComponentUuid();
- this.projectName = groupPermissionDto.getComponentName();
+ this.componentUuid = groupPermissionDto.getComponentUuid();
+ this.role = groupPermissionDto.getRole();
+ this.componentName = componentName;
+ this.qualifier = getQualifier(qualifier);
}
- public PermissionNewValue(UserPermissionDto permissionDto, @Nullable String projectName) {
+ public PermissionNewValue(UserPermissionDto permissionDto, @Nullable String componentName, @Nullable String qualifier) {
this.permissionUuid = permissionDto.getUuid();
this.userUuid = permissionDto.getUserUuid();
- this.projectUuid = permissionDto.getComponentUuid();
+ this.componentUuid = permissionDto.getComponentUuid();
this.role = permissionDto.getPermission();
- this.projectName = projectName;
+ this.componentName = componentName;
+ this.qualifier = getQualifier(qualifier);
}
public PermissionNewValue(@Nullable String role, @Nullable String groupUuid, @Nullable String groupName, @Nullable String rootComponentUuid,
- @Nullable String projectName, @Nullable String userUuid) {
+ @Nullable String componentName, @Nullable String qualifier, @Nullable String userUuid) {
this.role = role;
this.groupUuid = groupUuid;
this.groupName = groupName;
- this.projectUuid = rootComponentUuid;
- this.projectName = projectName;
+ this.componentUuid = rootComponentUuid;
+ this.componentName = componentName;
this.userUuid = userUuid;
+ this.qualifier = getQualifier(qualifier);
}
@CheckForNull
}
@CheckForNull
- public String getProjectUuid() {
- return this.projectUuid;
+ public String getComponentUuid() {
+ return this.componentUuid;
}
@CheckForNull
}
@CheckForNull
- public String getProjectName() {
- return this.projectName;
+ public String getComponentName() {
+ return this.componentName;
+ }
+
+ @CheckForNull
+ public String getQualifier() {
+ return this.qualifier;
}
@CheckForNull
addField(sb, "\"role\": ", this.role, true);
addField(sb, "\"groupUuid\": ", this.groupUuid, true);
addField(sb, "\"groupName\": ", this.groupName, true);
- addField(sb, "\"projectUuid\": ", this.projectUuid, true);
- addField(sb, "\"projectName\": ", this.projectName, true);
+ addField(sb, "\"componentUuid\": ", this.componentUuid, true);
+ addField(sb, "\"componentName\": ", this.componentName, true);
+ addField(sb, "\"qualifier\": ", this.qualifier, true);
addField(sb, "\"userUuid\": ", this.userUuid, true);
endString(sb);
return sb.toString();
import org.apache.commons.lang.ObjectUtils;
import org.sonar.db.permission.template.PermissionTemplateDto;
-public class PermissionTemplateNewValue implements NewValue {
+public class PermissionTemplateNewValue extends NewValue {
private String templateUuid;
private String name;
import org.sonar.db.alm.setting.AlmSettingDto;
import org.sonar.db.user.UserDto;
-public class PersonalAccessTokenNewValue implements NewValue {
+public class PersonalAccessTokenNewValue extends NewValue {
@Nullable
private String patUuid;
import org.sonar.db.plugin.PluginDto;
-public class PluginNewValue implements NewValue {
+public class PluginNewValue extends NewValue {
private String pluginUuid;
private String kee;
private String basePluginKey;
import org.apache.commons.lang.ObjectUtils;
-public class ProjectNewValue implements NewValue{
+public class ProjectNewValue extends NewValue{
private final String uuid;
private String name;
private String description;
private Boolean isPrivate;
- public ProjectNewValue(String uuid, String name) {
- this.uuid = uuid;
- this.name = name;
- }
-
- public ProjectNewValue(String uuid, boolean isPrivate) {
- this.uuid = uuid;
- this.isPrivate = isPrivate;
- }
-
public ProjectNewValue(String uuid, boolean isPrivate, String name, String description) {
this.uuid = uuid;
this.isPrivate = isPrivate;
import org.sonar.db.property.PropertyDto;
import org.sonar.db.user.UserPropertyDto;
-public class PropertyNewValue implements NewValue {
+public class PropertyNewValue extends NewValue {
@Nullable
private String propertyKey;
private String userLogin;
@Nullable
- private String projectUuid;
+ private String componentUuid;
@Nullable
- private String projectName;
+ private String componentName;
+
+ @Nullable
+ private String qualifier;
public PropertyNewValue(UserPropertyDto userPropertyDto, String login) {
this.propertyKey = userPropertyDto.getKey();
setValue(propertyKey, userPropertyDto.getValue());
}
- public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String projectName) {
+ public PropertyNewValue(PropertyDto propertyDto, @Nullable String userLogin, @Nullable String componentName, @Nullable String qualifier) {
this.propertyKey = propertyDto.getKey();
this.userUuid = propertyDto.getUserUuid();
this.userLogin = userLogin;
- this.projectUuid = propertyDto.getComponentUuid();
- this.projectName = projectName;
+ this.componentUuid = propertyDto.getComponentUuid();
+ this.componentName = componentName;
+ this.qualifier = getQualifier(qualifier);
setValue(propertyKey, propertyDto.getValue());
}
}
public PropertyNewValue(@Nullable String propertyKey, @Nullable String projectUuid,
- @Nullable String projectName, @Nullable String userUuid) {
+ @Nullable String componentName, @Nullable String qualifier, @Nullable String userUuid) {
this.propertyKey = propertyKey;
- this.projectUuid = projectUuid;
- this.projectName = projectName;
+ this.componentUuid = projectUuid;
+ this.componentName = componentName;
this.userUuid = userUuid;
+ this.qualifier = getQualifier(qualifier);
}
@CheckForNull
}
@CheckForNull
- public String getProjectUuid() {
- return this.projectUuid;
+ public String getComponentUuid() {
+ return this.componentUuid;
+ }
+
+ @CheckForNull
+ public String getComponentName() {
+ return this.componentName;
}
@CheckForNull
- public String getProjectName() {
- return this.projectName;
+ public String getQualifier() {
+ return this.qualifier;
}
@Override
addField(sb, "\"propertyValue\": ", this.propertyValue, true);
addField(sb, "\"userUuid\": ", this.userUuid, true);
addField(sb, "\"userLogin\": ", this.userLogin, true);
- addField(sb, "\"projectUuid\": ", this.projectUuid, true);
- addField(sb, "\"projectName\": ", this.projectName, true);
+ addField(sb, "\"componentUuid\": ", this.componentUuid, true);
+ addField(sb, "\"componentName\": ", this.componentName, true);
+ addField(sb, "\"qualifier\": ", this.qualifier, true);
endString(sb);
return sb.toString();
}
import org.sonar.db.user.UserDto;
import org.sonar.db.user.UserGroupDto;
-public class UserGroupNewValue implements NewValue {
+public class UserGroupNewValue extends NewValue {
@Nullable
private String groupUuid;
import org.apache.commons.lang.ObjectUtils;
import org.sonar.db.user.UserDto;
-public class UserNewValue implements NewValue {
+public class UserNewValue extends NewValue {
private String userUuid;
private String login;
import org.sonar.db.user.UserDto;
import org.sonar.db.user.UserTokenDto;
-public class UserTokenNewValue implements NewValue {
+public class UserTokenNewValue extends NewValue {
@Nullable
private String tokenUuid;
import org.sonar.db.project.ProjectDto;
import org.sonar.db.webhook.WebhookDto;
-public class WebhookNewValue implements NewValue {
+public class WebhookNewValue extends NewValue {
@Nullable
private String webhookUuid;
/**
* Returns the names of the groups that match the given query.
* The virtual group "Anyone" may be returned as the value {@link DefaultGroups#ANYONE}.
+ *
* @return group names, sorted in alphabetical order
*/
public List<String> selectGroupNamesByQuery(DbSession dbSession, PermissionQuery query) {
return mapper(session).selectGroupUuidsWithPermissionOnProjectBut(projectUuid, permission);
}
- public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto) {
+ public void insert(DbSession dbSession, GroupPermissionDto groupPermissionDto, @Nullable ComponentDto componentDto) {
mapper(dbSession).insert(groupPermissionDto);
if (auditPersister != null) {
- auditPersister.addGroupPermission(dbSession, new PermissionNewValue(groupPermissionDto));
+ String componentName = (componentDto != null) ? componentDto.name() : null;
+ String qualifier = (componentDto != null) ? componentDto.qualifier() : null;
+ auditPersister.addGroupPermission(dbSession, new PermissionNewValue(groupPermissionDto, componentName, qualifier));
}
}
/**
* Delete all the permissions associated to a root component (project)
*/
- public void deleteByRootComponentUuid(DbSession dbSession, String rootComponentUuid, String projectName) {
- mapper(dbSession).deleteByRootComponentUuid(rootComponentUuid);
+ public void deleteByRootComponentUuid(DbSession dbSession, ComponentDto component) {
+ mapper(dbSession).deleteByRootComponentUuid(component.uuid());
if (auditPersister != null) {
- auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, rootComponentUuid, projectName, null));
+ auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(), component.name(),
+ component.qualifier(), null));
}
}
* Delete all permissions of the specified group (group "AnyOne" if {@code groupUuid} is {@code null}) for the specified
* component.
*/
- public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, String rootComponentUuid, @Nullable String groupUuid) {
- return mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(rootComponentUuid, groupUuid);
+ public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, @Nullable String groupUuid, ComponentDto component) {
+ int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), groupUuid);
+
+ if (auditPersister != null) {
+ auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, groupUuid, "", component.uuid(), component.name(),
+ component.qualifier(), null));
+ }
+ return deletedRecords;
}
- public int deleteByRootComponentUuidForAnyOne(DbSession dbSession, String rootComponentUuid, String projectName) {
- int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(rootComponentUuid, null);
+ public int deleteByRootComponentUuidForAnyOne(DbSession dbSession, ComponentDto component) {
+ int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), null);
if (auditPersister != null) {
- auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, rootComponentUuid, projectName, null));
+ auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(),
+ component.name(), component.qualifier(), null));
}
return deletedRecords;
/**
* Delete the specified permission for the specified component for any group (including group AnyOne).
*/
- public int deleteByRootComponentUuidAndPermission(DbSession dbSession, String rootComponentUuid, String permission, String projectName) {
- int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndPermission(rootComponentUuid, permission);
+ public int deleteByRootComponentUuidAndPermission(DbSession dbSession, String permission, ComponentDto component) {
+ int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndPermission(component.uuid(), permission);
if (auditPersister != null) {
- auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, null, null, rootComponentUuid, projectName, null));
+ auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, null, null, component.uuid(),
+ component.name(), component.qualifier(), null));
}
return deletedRecords;
* <li>a permission granted to a group for a project</li>
* <li>a permission granted to anyone for a project</li>
* </ul>
+ *
* @param dbSession
- * @param permission the kind of permission
- * @param groupUuid if null, then anyone, else uuid of group
+ * @param permission the kind of permission
+ * @param groupUuid if null, then anyone, else uuid of group
* @param rootComponentUuid if null, then global permission, otherwise the uuid of root component (project)
*/
public void delete(DbSession dbSession, String permission,
if (auditPersister != null) {
String projectName = (componentDto != null) ? componentDto.name() : null;
- auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, groupUuid, groupName, rootComponentUuid, projectName, null));
+ String qualifier = (componentDto != null) ? componentDto.qualifier() : null;
+ auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, groupUuid, groupName, rootComponentUuid,
+ projectName, qualifier, null));
}
}
mapper(dbSession).insert(dto);
if (auditPersister != null) {
- String projectName = (componentDto != null) ? componentDto.name() : null;
- auditPersister.addUserPermission(dbSession, new PermissionNewValue(dto, projectName));
+ String componentName = (componentDto != null) ? componentDto.name() : null;
+ String qualifier = (componentDto != null) ? componentDto.qualifier() : null;
+ auditPersister.addUserPermission(dbSession, new PermissionNewValue(dto, componentName, qualifier));
}
}
mapper(dbSession).deleteGlobalPermission(userUuid, permission);
if (auditPersister != null) {
- auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, null,
- null, userUuid));
+ auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null,
+ null, null, null, userUuid));
}
}
/**
* Removes a single project permission from user
*/
- public void deleteProjectPermission(DbSession dbSession, String userUuid, String permission, String projectUuid, @Nullable String projectName) {
- mapper(dbSession).deleteProjectPermission(userUuid, permission, projectUuid);
+ public void deleteProjectPermission(DbSession dbSession, String userUuid, String permission, ComponentDto component) {
+ mapper(dbSession).deleteProjectPermission(userUuid, permission, component.uuid());
if (auditPersister != null) {
- auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, projectUuid, projectName, userUuid));
+ auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, component.uuid(),
+ component.name(), component.qualifier(), userUuid));
}
}
/**
* Deletes all the permissions defined on a project
*/
- public void deleteProjectPermissions(DbSession dbSession, String projectUuid, String projectName) {
- mapper(dbSession).deleteProjectPermissions(projectUuid);
+ public void deleteProjectPermissions(DbSession dbSession, ComponentDto component) {
+ mapper(dbSession).deleteProjectPermissions(component.uuid());
if (auditPersister != null) {
- auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, projectUuid, projectName, null));
+ auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(), component.name(),
+ component.qualifier(), null));
}
}
/**
* Deletes the specified permission on the specified project for any user.
*/
- public int deleteProjectPermissionOfAnyUser(DbSession dbSession, String projectUuid, String permission, String projectName) {
- int deletedRows = mapper(dbSession).deleteProjectPermissionOfAnyUser(projectUuid, permission);
+ public int deleteProjectPermissionOfAnyUser(DbSession dbSession, String permission, ComponentDto project) {
+ int deletedRows = mapper(dbSession).deleteProjectPermissionOfAnyUser(project.uuid(), permission);
if (auditPersister != null) {
- auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, projectUuid, projectName, null));
+ auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, project.uuid(), project.name(),
+ project.qualifier(), null));
}
return deletedRows;
mapper(dbSession).deleteByUserUuid(userUuid);
if (auditPersister != null) {
- auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, null, null, userUuid));
+ auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, null,
+ null, null, userUuid));
}
}
*
* @throws IllegalArgumentException if {@link PropertyDto#getKey()} is {@code null} or empty
*/
- public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectName) {
+ public void saveProperty(DbSession session, PropertyDto property, @Nullable String userLogin, @Nullable String projectName,
+ @Nullable String qualifier) {
save(getMapper(session), property.getKey(), property.getUserUuid(), property.getComponentUuid(), property.getValue());
if (auditPersister != null && auditPersister.isTrackedProperty(property.getKey())) {
- auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectName), false);
+ auditPersister.addProperty(session, new PropertyNewValue(property, userLogin, projectName, qualifier), false);
}
}
public void saveProperty(PropertyDto property) {
try (DbSession session = mybatis.openSession(false)) {
- saveProperty(session, property, null, null);
+ saveProperty(session, property, null, null, null);
session.commit();
}
}
if (auditPersister != null && query.key() != null && auditPersister.isTrackedProperty(query.key())) {
auditPersister.deleteProperty(dbSession, new PropertyNewValue(query.key(), query.componentUuid(),
- null, query.userUuid()), false);
+ null, null, query.userUuid()), false);
}
return deletedRows;
}
- public int delete(DbSession dbSession, PropertyDto dto, @Nullable String userLogin, @Nullable String projectName) {
+ public int delete(DbSession dbSession, PropertyDto dto, @Nullable String userLogin, @Nullable String projectName, @Nullable String qualifier) {
int deletedRows = getMapper(dbSession).delete(dto.getKey(), dto.getUserUuid(), dto.getComponentUuid());
if (auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) {
- auditPersister.deleteProperty(dbSession, new PropertyNewValue(dto, userLogin, projectName), false);
+ auditPersister.deleteProperty(dbSession, new PropertyNewValue(dto, userLogin, projectName, qualifier), false);
}
return deletedRows;
}
- public void deleteProjectProperty(String key, String projectUuid, String projectName) {
+ public void deleteProjectProperty(String key, String projectUuid, String projectName, String qualifier) {
try (DbSession session = mybatis.openSession(false)) {
- deleteProjectProperty(key, projectUuid, session, projectName);
+ deleteProjectProperty(session, key, projectUuid, projectName, qualifier);
session.commit();
}
}
- public void deleteProjectProperty(String key, String projectUuid, DbSession session, String projectName) {
+ public void deleteProjectProperty(DbSession session, String key, String projectUuid, String projectName, String qualifier) {
getMapper(session).deleteProjectProperty(key, projectUuid);
if (auditPersister != null && auditPersister.isTrackedProperty(key)) {
- auditPersister.deleteProperty(session, new PropertyNewValue(key, projectUuid, projectName, null), false);
+ auditPersister.deleteProperty(session, new PropertyNewValue(key, projectUuid, projectName, qualifier,
+ null), false);
}
}
}
@Test
- public void toString_addsPortfolioPrefix() {
+ public void toString_addsPortfolioQualifier() {
ComponentNewValue newValue = new ComponentNewValue("uuid", "name", "key", true, "path", "VW");
- assertThat(newValue.toString()).contains("portfolioUuid");
+ assertThat(newValue.toString())
+ .contains("componentUuid")
+ .contains("\"qualifier\": \"portfolio\"");
}
@Test
public void toString_project_uuid_and_name_and_isPrivate() {
ComponentNewValue newValue = new ComponentNewValue("uuid", "name", true,"TRK");
- assertThat(newValue.toString()).contains("\"projectUuid\": \"uuid\"");
- assertThat(newValue.toString()).contains("\"projectName\": \"name\"");
- assertThat(newValue.toString()).contains("\"isPrivate\": true");
+ assertThat(newValue.toString())
+ .contains("\"componentUuid\": \"uuid\"")
+ .contains("\"componentName\": \"name\"")
+ .contains("\"qualifier\": \"project\"")
+ .contains("\"isPrivate\": true");
}
@Test
public void toString_project_uuid_and_name_and_key() {
ComponentNewValue newValue = new ComponentNewValue("uuid", "name", "key", "TRK");
- assertThat(newValue.toString()).contains("\"projectUuid\": \"uuid\"");
- assertThat(newValue.toString()).contains("\"projectName\": \"name\"");
- assertThat(newValue.toString()).contains("\"key\": \"key\"");
+ assertThat(newValue.toString())
+ .contains("\"componentUuid\": \"uuid\"")
+ .contains("\"componentName\": \"name\"")
+ .contains("\"qualifier\": \"project\"")
+ .contains("\"key\": \"key\"");
}
@Test
public void toString_project_uuid_and_name_and_key_and_isPrivate_and_description() {
ComponentNewValue newValue = new ComponentNewValue("uuid", true, "name", "key", "description", "TRK");
- assertThat(newValue.toString()).contains("\"projectUuid\": \"uuid\"");
- assertThat(newValue.toString()).contains("\"projectName\": \"name\"");
- assertThat(newValue.toString()).contains("\"isPrivate\": true");
- assertThat(newValue.toString()).contains("\"key\": \"key\"");
- assertThat(newValue.toString()).contains("\"description\": \"description\"");
+ assertThat(newValue.toString())
+ .contains("\"componentUuid\": \"uuid\"")
+ .contains("\"componentName\": \"name\"")
+ .contains("\"qualifier\": \"project\"")
+ .contains("\"isPrivate\": true")
+ .contains("\"key\": \"key\"")
+ .contains("\"description\": \"description\"");
}
@Test
- public void toString_addsProjectPrefix() {
+ public void toString_addsProjectQualifier() {
ComponentNewValue newValue = new ComponentNewValue("uuid", "name", "key", true, "path", "TRK");
- assertThat(newValue.toString()).contains("projectUuid");
+ assertThat(newValue.toString())
+ .contains("componentUuid")
+ .contains("\"qualifier\": \"project\"");
}
@Test
- public void toString_addsApplicationPrefix() {
+ public void toString_addsApplicationQualifier() {
ComponentNewValue newValue = new ComponentNewValue("uuid", "name", "key", true, "path", "APP");
- assertThat(newValue.toString()).contains("applicationUuid");
+ assertThat(newValue.toString())
+ .contains("componentUuid")
+ .contains("\"qualifier\": \"application\"");
}
}
db.users().insertProjectPermissionOnGroup(group1, "perm2", project1);
db.users().insertProjectPermissionOnGroup(group2, "perm3", project2);
- underTest.deleteByRootComponentUuid(dbSession, project1.uuid(), project1.name());
+ underTest.deleteByRootComponentUuid(dbSession, project1);
dbSession.commit();
assertThat(db.countSql("select count(uuid) from group_roles where component_uuid='" + project1.uuid() + "'")).isZero();
db.users().insertProjectPermissionOnAnyone("perm4", project1);
db.users().insertProjectPermissionOnAnyone("perm5", project2);
- underTest.deleteByRootComponentUuid(dbSession, project1.uuid(), project1.name());
+ underTest.deleteByRootComponentUuid(dbSession, project1);
dbSession.commit();
assertThat(db.countSql("select count(uuid) from group_roles where component_uuid='" + project1.uuid() + "'")).isZero();
assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, group.getUuid()))
.containsOnly("p4");
- int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null);
+ int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, null, project);
assertThat(deletedCount).isEqualTo(1);
assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, null, project.uuid()))
assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, group2.getUuid()))
.containsOnly("p7");
- int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group1.getUuid());
+ int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, group1.getUuid(), project);
assertThat(deletedCount).isEqualTo(1);
assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, null, project.uuid()))
assertThat(underTest.selectGlobalPermissionsOfGroup(dbSession, group2.getUuid()))
.containsOnly("p7");
- deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group2.getUuid());
+ deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, group2.getUuid(), project);
assertThat(deletedCount).isEqualTo(2);
assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, null, project.uuid()))
@Test
public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_component_does_not_exist() {
GroupDto group = db.users().insertGroup();
+ ComponentDto component = new ComponentDto().setUuid("1234");
- assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, "1234", null)).isZero();
- assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, "1234", group.getUuid())).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, null, component)).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, group.getUuid(), component)).isZero();
}
@Test
ComponentDto project = randomPublicOrPrivateProject();
GroupDto group = db.users().insertGroup();
- assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null)).isZero();
- assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group.getUuid())).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, null, project)).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, group.getUuid(), project)).isZero();
}
@Test
public void deleteByRootComponentUuidAndGroupUuid_has_no_effect_if_group_does_not_exist() {
ComponentDto project = randomPublicOrPrivateProject();
- assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), "5678")).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, "5678", project)).isZero();
}
@Test
db.users().insertPermissionOnAnyone("p2");
db.users().insertPermissionOnGroup(group1, "p3");
- int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), null);
+ int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, null, project);
assertThat(deletedCount).isZero();
assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, null, project.uuid()))
db.users().insertPermissionOnAnyone("p2");
db.users().insertPermissionOnGroup(group1, "p3");
- int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, project.uuid(), group2.getUuid());
+ int deletedCount = underTest.deleteByRootComponentUuidAndGroupUuid(dbSession, group2.getUuid(), project);
assertThat(deletedCount).isZero();
assertThat(underTest.selectProjectPermissionsOfGroup(dbSession, group1.getUuid(), project.uuid()))
assertThat(getProjectPermissionsForAnyOne(project)).containsOnly("p1", "p2");
assertThat(getProjectPermissionsForGroup(project, group)).containsOnly("p1", "p2");
- int deletedRows = underTest.deleteByRootComponentUuidAndPermission(dbSession, project.uuid(), "p1", project.name());
+ int deletedRows = underTest.deleteByRootComponentUuidAndPermission(dbSession, "p1", project);
assertThat(deletedRows).isEqualTo(2);
assertThat(getGlobalPermissionsForAnyone()).containsOnly("p1", "p2");
assertThat(getProjectPermissionsForAnyOne(project)).containsOnly("p2");
assertThat(getProjectPermissionsForGroup(project, group)).containsOnly("p2");
- deletedRows = underTest.deleteByRootComponentUuidAndPermission(dbSession, project.uuid(), "p2", project.name());
+ deletedRows = underTest.deleteByRootComponentUuidAndPermission(dbSession, "p2", project);
assertThat(deletedRows).isEqualTo(2);
assertThat(getGlobalPermissionsForAnyone()).containsOnly("p1", "p2");
db.users().insertPermissionOnAnyone("p1");
db.users().insertPermissionOnGroup(group, "p1");
- assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, project.uuid(), "p1", project.name())).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, "p1", project)).isZero();
assertThat(getGlobalPermissionsForAnyone()).containsOnly("p1");
assertThat(getGlobalPermissionsForGroup(group)).containsOnly("p1");
db.users().insertProjectPermissionOnGroup(group, "p1", project);
db.users().insertProjectPermissionOnAnyone("p1", project);
- assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, "1324", "p1", "")).isZero();
+ ComponentDto anotherProject = new ComponentDto().setUuid("1324");
+
+ assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, "p1", anotherProject)).isZero();
assertThat(getGlobalPermissionsForAnyone()).containsOnly("p1");
assertThat(getGlobalPermissionsForGroup(group)).containsOnly("p1");
db.users().insertPermissionOnAnyone("p1");
db.users().insertPermissionOnGroup(group, "p1");
- assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, project.uuid(), "p1", project.name())).isZero();
+ assertThat(underTest.deleteByRootComponentUuidAndPermission(dbSession, "p1", project)).isZero();
}
private Collection<String> getGlobalPermissionsForAnyone() {
.setGroupUuid(group.getUuid())
.setGroupName(group.getName())
.setRole(ADMIN);
- underTest.insert(dbSession, dto);
+ underTest.insert(dbSession, dto, null);
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), null, dto.getRole(), null);
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), null, dto.getRole(), null, null);
assertThat(newValue.toString()).doesNotContain("projectUuid");
underTest.delete(dbSession, ADMIN, group.getUuid(), group.getName(), null, null);
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
.containsExactly(null, group.getUuid(), group.getName(), null, ADMIN, null);
assertThat(newValue.toString()).doesNotContain("permissionUuid");
}
GroupDto group = db.users().insertGroup();
ComponentDto project = db.components().insertPrivateProject();
GroupPermissionDto dto = getGroupPermission(group, project);
- underTest.insert(dbSession, dto);
+ underTest.insert(dbSession, dto, project);
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name());
- assertThat(newValue.toString()).contains("projectUuid");
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name(), "project");
+ assertThat(newValue.toString()).contains("componentUuid");
- underTest.deleteByRootComponentUuid(dbSession, project.uuid(), project.name());
+ underTest.deleteByRootComponentUuid(dbSession, project);
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
.containsExactly(null, null, null, project.uuid(), null, project.name());
assertThat(newValue.toString()).doesNotContain("permissionUuid");
}
GroupDto group = db.users().insertGroup();
ComponentDto project = db.components().insertPrivateProject();
GroupPermissionDto dto = getGroupPermission(group, project);
- underTest.insert(dbSession, dto);
+ underTest.insert(dbSession, dto, project);
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name());
- assertThat(newValue.toString()).contains("projectUuid");
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name(), "project");
+ assertThat(newValue.toString()).contains("componentUuid");
- underTest.deleteByRootComponentUuidForAnyOne(dbSession, project.uuid(), project.name());
+ underTest.deleteByRootComponentUuidForAnyOne(dbSession, project);
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(null, project.uuid(), null, project.name());
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
+ .containsExactly(null, null, null, project.uuid(), null, project.name());
assertThat(newValue.toString()).doesNotContain("permissionUuid");
}
GroupDto group = db.users().insertGroup();
ComponentDto project = db.components().insertPrivateProject();
GroupPermissionDto dto = getGroupPermission(group, project);
- underTest.insert(dbSession, dto);
+ underTest.insert(dbSession, dto, project);
verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getGroupName, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name());
- assertThat(newValue.toString()).contains("projectUuid");
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
+ PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name(), "project");
+ assertThat(newValue.toString()).contains("componentUuid");
- underTest.deleteByRootComponentUuidAndPermission(dbSession, project.uuid(), dto.getRole(), project.name());
+ underTest.deleteByRootComponentUuidAndPermission(dbSession, dto.getRole(), project);
verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
.containsExactly(null, null, project.uuid(), ADMIN, project.name());
assertThat(newValue.toString()).doesNotContain("permissionUuid");
}
addProjectPermission("perm", user2, project1);
// no such provision -> ignore
- underTest.deleteProjectPermission(dbSession, user1.getUuid(), "anotherPerm", project1.uuid(), project1.name());
+ underTest.deleteProjectPermission(dbSession, user1.getUuid(), "anotherPerm", project1);
assertThat(db.countRowsOfTable(dbSession, "user_roles")).isEqualTo(4);
- underTest.deleteProjectPermission(dbSession, user1.getUuid(), "perm", project1.uuid(), project1.name());
+ underTest.deleteProjectPermission(dbSession, user1.getUuid(), "perm", project1);
assertThatProjectPermissionDoesNotExist(user1, "perm", project1);
assertThat(db.countRowsOfTable(dbSession, "user_roles")).isEqualTo(3);
}
addProjectPermission("perm", user2, project1);
addProjectPermission("perm", user1, project2);
- underTest.deleteProjectPermissions(dbSession, project1.uuid(), project1.name());
+ underTest.deleteProjectPermissions(dbSession, project1);
assertThat(db.countRowsOfTable(dbSession, "user_roles")).isEqualTo(2);
assertThatProjectHasNoPermissions(project1);
}
public void deleteProjectPermissionOfAnyUser_has_no_effect_if_specified_component_does_not_exist() {
UserDto user = insertUser();
db.users().insertPermissionOnUser(user, SCAN);
+ ComponentDto component = newPrivateProjectDto();
- int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, "124", SCAN.getKey(), "");
+ int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN.getKey(), component);
assertThat(deletedCount).isZero();
assertThat(underTest.selectGlobalPermissionsOfUser(dbSession, user.getUuid())).containsOnly(SCAN.getKey());
db.users().insertPermissionOnUser(user, SCAN);
ComponentDto project = randomPublicOrPrivateProject();
- int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, project.uuid(), SCAN.getKey(), "");
+ int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN.getKey(), project);
assertThat(deletedCount).isZero();
assertThat(underTest.selectGlobalPermissionsOfUser(dbSession, user.getUuid())).containsOnly(SCAN.getKey());
ComponentDto project = randomPublicOrPrivateProject();
db.users().insertProjectPermissionOnUser(user, SCAN.getKey(), project);
- int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, project.uuid(), "p1", project.name());
+ int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, "p1", project);
assertThat(deletedCount).isZero();
assertThat(underTest.selectGlobalPermissionsOfUser(dbSession, user.getUuid())).containsOnly(SCAN.getKey());
db.users().insertProjectPermissionOnUser(user2, SCAN.getKey(), project2);
db.users().insertProjectPermissionOnUser(user2, PROVISION_PROJECTS.getKey(), project2);
- int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, project1.uuid(), SCAN.getKey(), project1.name());
+ int deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN.getKey(), project1);
assertThat(deletedCount).isEqualTo(2);
assertThat(underTest.selectGlobalPermissionsOfUser(dbSession, user1.getUuid())).containsOnly(SCAN.getKey());
assertThat(underTest.selectProjectPermissionsOfUser(dbSession, user1.getUuid(), project2.uuid())).containsOnly(SCAN.getKey());
assertThat(underTest.selectProjectPermissionsOfUser(dbSession, user2.getUuid(), project2.uuid())).containsOnly(SCAN.getKey(), PROVISION_PROJECTS.getKey());
- deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, project2.uuid(), SCAN.getKey(), project2.name());
+ deletedCount = underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN.getKey(), project2);
assertThat(deletedCount).isEqualTo(2);
assertThat(underTest.selectGlobalPermissionsOfUser(dbSession, user1.getUuid())).containsOnly(SCAN.getKey());
verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), user.getUuid(), null, dto.getPermission(), null);
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), user.getUuid(), null, dto.getPermission(), null, null);
assertThat(newValue.toString()).doesNotContain("projectUuid");
underTest.deleteGlobalPermission(dbSession, user.getUuid(), SYSTEM_ADMIN);
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
.containsExactly(null, user.getUuid(), null, dto.getPermission(), null);
assertThat(newValue.toString()).doesNotContain("permissionUuid");
}
verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(dto.getUuid(), user.getUuid(), project.uuid(), dto.getPermission(), project.name());
- assertThat(newValue.toString()).contains("projectUuid");
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), user.getUuid(), project.uuid(), dto.getPermission(), project.name(), "project");
+ assertThat(newValue.toString()).contains("componentUuid");
- underTest.deleteProjectPermission(dbSession, user.getUuid(), SYSTEM_ADMIN, project.projectUuid(), project.name());
+ underTest.deleteProjectPermission(dbSession, user.getUuid(), SYSTEM_ADMIN, project);
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture());
newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName)
.containsExactly(null, user.getUuid(), project.uuid(), dto.getPermission(), project.name());
- assertThat(newValue.toString()).doesNotContain("permissionUuid");
+ assertThat(newValue.toString())
+ .doesNotContain("permissionUuid");
+ }
+
+ @Test
+ public void userPortfolioPermissionIsPersisted() {
+ UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
+ ComponentDto portfolio = db.components().insertPublicPortfolio();
+ UserPermissionDto dto = new UserPermissionDto(Uuids.create(), SYSTEM_ADMIN, user.getUuid(), portfolio.uuid());
+ underTest.insert(dbSession, dto, portfolio);
+
+ verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture());
+ PermissionNewValue newValue = newValueCaptor.getValue();
+ assertThat(newValue)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), user.getUuid(), portfolio.uuid(), dto.getPermission(), portfolio.name(), "portfolio");
+ assertThat(newValue.toString())
+ .contains("componentUuid");
+ }
+
+ @Test
+ public void userApplicationPermissionIsPersisted() {
+ UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
+ ComponentDto application = db.components().insertPublicApplication();
+ UserPermissionDto dto = new UserPermissionDto(Uuids.create(), SYSTEM_ADMIN, user.getUuid(), application.uuid());
+ underTest.insert(dbSession, dto, application);
+
+ verify(auditPersister).addUserPermission(eq(dbSession), newValueCaptor.capture());
+ PermissionNewValue newValue = newValueCaptor.getValue();
+ assertThat(newValue)
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(dto.getUuid(), user.getUuid(), application.uuid(), dto.getPermission(), application.name(), "application");
+ assertThat(newValue.toString())
+ .contains("componentUuid");
}
@Test
ComponentDto project = db.components().insertPrivateProject();
UserPermissionDto dto = new UserPermissionDto(Uuids.create(), SCAN_EXECUTION, user.getUuid(), project.uuid());
underTest.insert(dbSession, dto, project);
- underTest.deleteProjectPermissionOfAnyUser(dbSession, project.projectUuid(), SCAN_EXECUTION, project.name());
+ underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN_EXECUTION, project);
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(null, null, project.uuid(), SCAN_EXECUTION, project.name());
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(null, null, project.uuid(), SCAN_EXECUTION, project.name(), "project");
assertThat(newValue.toString()).doesNotContain("userUuid");
}
verify(auditPersister).deleteUserPermission(eq(dbSession), newValueCaptor.capture());
PermissionNewValue newValue = newValueCaptor.getValue();
assertThat(newValue)
- .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getProjectUuid,
- PermissionNewValue::getRole, PermissionNewValue::getProjectName)
- .containsExactly(null, user.getUuid(), null, null, null);
+ .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getUserUuid, PermissionNewValue::getComponentUuid,
+ PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
+ .containsExactly(null, user.getUuid(), null, null, null, null);
assertThat(newValue.toString()).contains("userUuid");
}
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.sonar.api.impl.utils.AlwaysIncreasingSystem2;
+import org.sonar.api.resources.Qualifiers;
import org.sonar.api.web.UserRole;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
public void select_by_key_and_matching_value() {
ComponentDto project1 = db.components().insertPrivateProject();
ComponentDto project2 = db.components().insertPrivateProject();
- db.properties().insertProperties(null, project1.name(), newComponentPropertyDto("key", "value", project1));
- db.properties().insertProperties(null, project2.name(), newComponentPropertyDto("key", "value", project2));
- db.properties().insertProperties(null, null, newGlobalPropertyDto("key", "value"));
- db.properties().insertProperties(null, project1.name(), newComponentPropertyDto("another key", "value", project1));
+ db.properties().insertProperties(null, project1.name(), project1.qualifier(), newComponentPropertyDto("key", "value", project1));
+ db.properties().insertProperties(null, project2.name(), project2.qualifier(), newComponentPropertyDto("key", "value", project2));
+ db.properties().insertProperties(null, null, null, newGlobalPropertyDto("key", "value"));
+ db.properties().insertProperties(null, project1.name(), project1.qualifier(), newComponentPropertyDto("another key", "value", project1));
assertThat(underTest.selectByKeyAndMatchingValue(db.getSession(), "key", "value"))
.extracting(PropertyDto::getValue, PropertyDto::getComponentUuid)
ComponentDto project1 = db.components().insertPrivateProject();
ComponentDto file1 = db.components().insertComponent(ComponentTesting.newFileDto(project1));
ComponentDto project2 = db.components().insertPrivateProject();
- db.properties().insertProperties(user1.getLogin(), project1.name(), newPropertyDto("key", "1", project1, user1));
- db.properties().insertProperties(user1.getLogin(), project2.name(), newPropertyDto("key", "2", project2, user1));
- db.properties().insertProperties(user1.getLogin(), file1.name(), newPropertyDto("key", "3", file1, user1));
- db.properties().insertProperties(user1.getLogin(), project1.name(), newPropertyDto("another key", "4", project1, user1));
- db.properties().insertProperties(user2.getLogin(), project1.name(), newPropertyDto("key", "5", project1, user2));
- db.properties().insertProperties(null, null, newGlobalPropertyDto("key", "global"));
+ db.properties().insertProperties(user1.getLogin(), project1.name(), project1.qualifier(), newPropertyDto("key", "1", project1, user1));
+ db.properties().insertProperties(user1.getLogin(), project2.name(), project2.qualifier(), newPropertyDto("key", "2", project2, user1));
+ db.properties().insertProperties(user1.getLogin(), file1.name(), null, newPropertyDto("key", "3", file1, user1));
+ db.properties().insertProperties(user1.getLogin(), project1.name(), project1.qualifier(), newPropertyDto("another key", "4", project1, user1));
+ db.properties().insertProperties(user2.getLogin(), project1.name(), project1.qualifier(), newPropertyDto("key", "5", project1, user2));
+ db.properties().insertProperties(null, null, null, newGlobalPropertyDto("key", "global"));
assertThat(underTest.selectByKeyAndUserUuidAndComponentQualifier(db.getSession(), "key", user1.getUuid(), "TRK"))
.extracting(PropertyDto::getValue).containsExactlyInAnyOrder("1", "2");
String uuid6 = insertProperty("user.two", "two", null, "100", "login", null);
String uuid7 = insertProperty("other.one", "one", "project3", null, null, "project3");
- underTest.deleteProjectProperty("struts.one", "project1", "project1");
+ underTest.deleteProjectProperty("struts.one", "project1", "project1", Qualifiers.PROJECT);
assertThatPropertiesRowByUuid(uuid1)
.hasKey("global.one")
private void insertProperties(@Nullable String userLogin, @Nullable String projectName, PropertyDto... properties) {
for (PropertyDto propertyDto : properties) {
- underTest.saveProperty(session, propertyDto, userLogin, projectName);
+ underTest.saveProperty(session, propertyDto, userLogin, projectName, Qualifiers.PROJECT);
}
session.commit();
}
.setComponentUuid(componentUuid)
.setUserUuid(userUuid)
.setValue(value);
- db.properties().insertProperty(dto, projectName, userLogin);
+ db.properties().insertProperty(dto, projectName, Qualifiers.PROJECT, userLogin);
return (String) db.selectFirst(session, "select uuid as \"uuid\" from properties" +
" where prop_key='" + key + "'" +
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.sonar.api.impl.utils.AlwaysIncreasingSystem2;
+import org.sonar.api.resources.Qualifiers;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
PropertyDto propertyDto = getPropertyDto(KEY);
- underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME);
+ underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(KEY);
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false));
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier)
.containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(),
- USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_NAME);
- assertThat(newValue.toString()).contains("projectUuid");
+ USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_NAME, "project");
+ assertThat(newValue.toString()).contains("componentUuid");
+ }
+
+ @Test
+ public void saveApplicationTrackedPropertyIsPersisted() {
+ when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+
+ PropertyDto propertyDto = getPropertyDto(KEY);
+ underTest.saveProperty(session, propertyDto, USER_LOGIN, "app-name", Qualifiers.APP);
+
+ verify(auditPersister).isTrackedProperty(KEY);
+ verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false));
+ PropertyNewValue newValue = newValueCaptor.getValue();
+ assertThat(newValue)
+ .extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
+ PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier)
+ .containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(),
+ USER_LOGIN, propertyDto.getComponentUuid(), "app-name", "application");
+ assertThat(newValue.toString())
+ .contains("componentUuid");
+ }
+
+ @Test
+ public void savePortfolioTrackedPropertyIsPersisted() {
+ when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+
+ PropertyDto propertyDto = getPropertyDto(KEY);
+ underTest.saveProperty(session, propertyDto, USER_LOGIN, "portfolio-name", Qualifiers.VIEW);
+
+ verify(auditPersister).isTrackedProperty(KEY);
+ verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false));
+ PropertyNewValue newValue = newValueCaptor.getValue();
+ assertThat(newValue)
+ .extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
+ PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier)
+ .containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(),
+ USER_LOGIN, propertyDto.getComponentUuid(), "portfolio-name", "portfolio");
+ assertThat(newValue.toString())
+ .contains("componentUuid");
}
@Test
when(auditPersister.isTrackedProperty(SECURED_KEY)).thenReturn(true);
PropertyDto propertyDto = getPropertyDto(SECURED_KEY);
- underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME);
+ underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(SECURED_KEY);
verify(auditPersister).addProperty(any(), newValueCaptor.capture(), eq(false));
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName, PropertyNewValue::getQualifier)
.containsExactly(propertyDto.getKey(), null, propertyDto.getUserUuid(),
- USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_NAME);
- assertThat(newValue.toString()).contains("projectUuid");
+ USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_NAME, "project");
+ assertThat(newValue.toString()).contains("componentUuid");
}
@Test
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(query.key(), null, query.userUuid(),
null, query.componentUuid(), null);
assertThat(newValue.toString()).doesNotContain("userLogin");
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
PropertyDto propertyDto = getPropertyDto(KEY);
- underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME);
+ underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(KEY);
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(propertyDto.getKey(), propertyDto.getValue(), propertyDto.getUserUuid(),
USER_LOGIN, propertyDto.getComponentUuid(), PROJECT_NAME);
assertThat(newValue.toString()).contains("userLogin");
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
PropertyDto propertyDto = getPropertyDto(KEY);
- underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME);
+ underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(KEY);
verifyNoMoreInteractions(auditPersister);
@Test
public void deleteTrackedProjectPropertyIsPersisted() {
when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
- underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_NAME);
+ underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(KEY);
verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, null, null,
null, PROJECT_UUID, PROJECT_NAME);
assertThat(newValue.toString()).doesNotContain("userLogin");
when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
PropertyDto propertyDto = getPropertyDto(KEY);
- underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME);
+ underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
verify(auditPersister).isTrackedProperty(KEY);
verifyNoMoreInteractions(auditPersister);
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, VALUE, null,
null, null, null);
assertThat(newValue.toString()).doesNotContain("projectUuid");
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, null, null,
null, null, null);
assertThat(newValue.toString()).doesNotContain("projectUuid");
assertThat(newValues.get(0))
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, null, user.getUuid(),
user.getLogin(), null, null);
assertThat(newValues.get(0).toString()).contains("userUuid");
assertThat(newValues.get(1))
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(SECURED_KEY, null, user.getUuid(),
user.getLogin(), null, null);
assertThat(newValues.get(1).toString()).doesNotContain("value");
assertThat(newValues.get(0))
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, null, null,
user.getLogin(), null, null);
assertThat(newValues.get(0).toString()).contains("userLogin");
assertThat(newValues.get(1))
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(SECURED_KEY, null, null,
user.getLogin(), null, null);
assertThat(newValues.get(1).toString()).doesNotContain("value");
assertThat(newValue)
.extracting(PropertyNewValue::getPropertyKey, PropertyNewValue::getPropertyValue,
PropertyNewValue::getUserUuid, PropertyNewValue::getUserLogin,
- PropertyNewValue::getProjectUuid, PropertyNewValue::getProjectName)
+ PropertyNewValue::getComponentUuid, PropertyNewValue::getComponentName)
.containsExactly(KEY, VALUE, null,
null, null, null);
assertThat(newValue.toString()).doesNotContain("projectUuid");
.setComponentUuid(project.uuid())
.setUserUuid(user.getUuid())
.setValue(value);
- db.properties().insertProperty(dto1, project.name(), user.getLogin());
- db.properties().insertProperty(dto2, project.name(), user.getLogin());
- db.properties().insertProperty(dto3, project.name(), user.getLogin());
- List<PropertyDto> list = db.getDbClient().propertiesDao().selectByKeyAndMatchingValue(session, KEY, VALUE);
- list = db.getDbClient().propertiesDao().selectByKeyAndMatchingValue(session, ANOTHER_KEY, VALUE);
- list = db.getDbClient().propertiesDao().selectByKeyAndMatchingValue(session, SECURED_KEY, VALUE);
+ db.properties().insertProperty(dto1, project.name(), project.qualifier(), user.getLogin());
+ db.properties().insertProperty(dto2, project.name(), project.qualifier(), user.getLogin());
+ db.properties().insertProperty(dto3, project.name(), project.qualifier(), user.getLogin());
return user;
}
}
.setKey(randomAlphabetic(3))
.setValue(randomAlphabetic(3))
.setComponentUuid(componentDto.uuid()),
- componentDto.name(), null));
+ componentDto.name(), componentDto.qualifier(), null));
}
private void insertPropertyFor(Collection<BranchDto> branches) {
.setKey(randomAlphabetic(3))
.setValue(randomAlphabetic(3))
.setComponentUuid(branchDto.getUuid()),
- branchDto.getKey(), null));
+ branchDto.getKey(), null,null));
}
private Stream<String> getComponentUuidsOfMeasures() {
verify(auditPersister).deleteComponent(any(DbSession.class), newValueCaptor.capture(), eq(project.qualifier()));
ComponentNewValue componentNewValue = newValueCaptor.getValue();
assertThat(componentNewValue)
- .extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getKey)
- .containsExactly(project.uuid(), project.name(), project.getKey());
+ .extracting(ComponentNewValue::getComponentUuid, ComponentNewValue::getComponentName, ComponentNewValue::getKey,
+ ComponentNewValue::getQualifier)
+ .containsExactly(project.uuid(), project.name(), project.getKey(), "project");
}
}
.setKey(PROP_FAVORITE_KEY)
.setUserUuid(userUuid)
.setComponentUuid(componentDto.uuid()),
- userLogin, componentDto.name());
+ userLogin, componentDto.name(), componentDto.qualifier());
dbSession.commit();
}
import java.util.Map;
import java.util.Optional;
import javax.annotation.Nullable;
-import org.sonar.core.util.UuidFactory;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
this.dbSession = db.getSession();
}
- public PropertyDto insertProperty(PropertyDto property, @Nullable String componentName, @Nullable String userLogin) {
- dbClient.propertiesDao().saveProperty(dbSession, property, userLogin, componentName);
+ public PropertyDto insertProperty(PropertyDto property, @Nullable String componentName, @Nullable String qualifier,
+ @Nullable String userLogin) {
+ dbClient.propertiesDao().saveProperty(dbSession, property, userLogin, qualifier, componentName);
db.commit();
return property;
}
- public void insertProperties(@Nullable String userLogin, @Nullable String projectName, PropertyDto... properties) {
- insertProperties(asList(properties), userLogin, projectName);
+ public void insertProperties(@Nullable String userLogin, @Nullable String projectName, @Nullable String qualifier,
+ PropertyDto... properties) {
+ insertProperties(asList(properties), userLogin, qualifier, projectName);
}
- public void insertProperties(List<PropertyDto> properties, @Nullable String userLogin, @Nullable String projectName) {
+ public void insertProperties(List<PropertyDto> properties, @Nullable String userLogin, @Nullable String projectName,
+ @Nullable String qualifier) {
for (PropertyDto propertyDto : properties) {
- dbClient.propertiesDao().saveProperty(dbSession, propertyDto, userLogin, projectName);
+ dbClient.propertiesDao().saveProperty(dbSession, propertyDto, userLogin, projectName, qualifier);
}
dbSession.commit();
}
propertyDtos.add(newGlobalPropertyDto().setKey(settingBaseKey).setValue(idsValue));
}
String componentName = componentDto == null ? null : componentDto.name();
- insertProperties(propertyDtos, null, componentName);
+ String qualififer = componentDto == null ? null : componentDto.qualifier();
+ insertProperties(propertyDtos, null, componentName, qualififer);
}
public PropertyDbTester verifyInternal(String key, @Nullable String expectedValue) {
.setUuid(Uuids.createFast())
.setGroupUuid(null)
.setRole(permission);
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, null);
db.commit();
return dto;
}
.setUuid(Uuids.createFast())
.setGroupUuid(group.getUuid())
.setRole(permission);
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, null);
db.commit();
return dto;
}
.setRole(permission)
.setComponentUuid(project.uuid())
.setComponentName(project.name());
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, project);
db.commit();
return dto;
}
.setRole(permission)
.setComponentUuid(project.uuid())
.setComponentName(project.name());
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, project);
db.commit();
return dto;
}
}
public void deletePermissionFromUser(ComponentDto project, UserDto user, String permission) {
- db.getDbClient().userPermissionDao().deleteProjectPermission(db.getSession(), user.getUuid(), permission, project.uuid(), project.name());
+ db.getDbClient().userPermissionDao().deleteProjectPermission(db.getSession(), user.getUuid(), permission, project);
db.commit();
}
.setComponentUuid(componentDto.uuid())
.setUserUuid(userUuid),
userLogin,
- componentDto.name());
+ componentDto.name(), componentDto.qualifier());
}
/**
.setKey(PROP_FAVORITE_KEY)
.setComponentUuid(component.uuid())
.setUserUuid(userUuid),
- userLogin, component.name());
+ userLogin, component.name(), component.qualifier());
checkArgument(result == 1, "Component '%s' is not a favorite", component.getDbKey());
}
}
private void testLoadingFromDatabase(SonarRuntime runtime, boolean isStartupLeader) {
dbTester.properties().insertProperty(new PropertyDto().setKey(CoreProperties.SERVER_STARTTIME).setValue(formatDateTime(A_DATE)),
- null, null);
+ null, null, null);
when(webServer.isStartupLeader()).thenReturn(isStartupLeader);
StartupMetadata metadata = underTest.provide(system, runtime, webServer, dbTester.getDbClient());
if (hasExternalPlugins && NOT_ACCEPTED == PluginRiskConsent.valueOf(property.getValue())) {
addWarningInSonarDotLog();
property.setValue(REQUIRED.name());
- dbClient.propertiesDao().saveProperty(session, property, null, null);
+ dbClient.propertiesDao().saveProperty(session, property, null, null, null);
session.commit();
} else if (!hasExternalPlugins && REQUIRED == PluginRiskConsent.valueOf(property.getValue())) {
dbClient.propertiesDao().deleteGlobalProperty(PLUGINS_RISK_CONSENT, session);
public void set(DbSession dbSession, Visibility visibility) {
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto()
.setKey(PROJECTS_DEFAULT_VISIBILITY_PROPERTY_NAME)
- .setValue(visibility.getLabel()), null, null);
+ .setValue(visibility.getLabel()), null, null, null);
}
}
ComponentDto project1 = db.components().insertPrivateProject();
ComponentDto project2 = db.components().insertPrivateProject();
ComponentDto anotherProject = db.components().insertPrivateProject();
- db.properties().insertProperties(oldUser.getLogin(), project1.name(),
+ db.properties().insertProperties(oldUser.getLogin(), project1.name(), project1.qualifier(),
new PropertyDto().setKey(DEFAULT_ISSUE_ASSIGNEE).setValue(oldUser.getLogin()),
new PropertyDto().setKey(DEFAULT_ISSUE_ASSIGNEE).setValue(oldUser.getLogin()).setComponentUuid(project1.uuid()));
- db.properties().insertProperties(oldUser.getLogin(), project2.name(),
+ db.properties().insertProperties(oldUser.getLogin(), project2.name(), project2.qualifier(),
new PropertyDto().setKey(DEFAULT_ISSUE_ASSIGNEE).setValue(oldUser.getLogin()).setComponentUuid(project2.uuid()));
- db.properties().insertProperties(oldUser.getLogin(), anotherProject.name(),
+ db.properties().insertProperties(oldUser.getLogin(), anotherProject.name(), anotherProject.qualifier(),
new PropertyDto().setKey(DEFAULT_ISSUE_ASSIGNEE).setValue("another login").setComponentUuid(anotherProject.uuid()));
userIndexer.indexAll();
if (value == null) {
dbClient.propertiesDao().deleteGlobalProperty(key, dbSession);
} else {
- dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(key).setValue(value), null, null);
+ dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(key).setValue(value), null, null, null);
}
// refresh the cache of settings
delegate.setProperty(key, value);
}
private void persistServerId(DbSession dbSession, ServerId serverId) {
- dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(SERVER_ID).setValue(serverId.toString()), null, null);
+ dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(SERVER_ID).setValue(serverId.toString()),
+ null, null, null);
}
private void persistChecksum(DbSession dbSession, String checksump) {
private void insertServerId(String serverId) {
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(CoreProperties.SERVER_ID).setValue(serverId),
- null, null);
+ null, null, null);
dbSession.commit();
}
.setRole(USER)
.setComponentUuid(project.uuid())
.setComponentName(project.name());
- dbClient.groupPermissionDao().insert(dbSession, dto);
+ dbClient.groupPermissionDao().insert(dbSession, dto, project);
}
dbSession.commit();
String key = String.join(".", PROP_NOTIFICATION_PREFIX, dispatcher, channel);
String projectUuid = project == null ? null : project.uuid();
String projectName = project == null ? null : project.name();
+ String qualifier = project == null ? null : project.qualifier();
List<PropertyDto> existingNotification = dbClient.propertiesDao().selectByQuery(
PropertyQuery.builder()
.setUserUuid(user.getUuid())
.setValue(PROP_NOTIFICATION_VALUE)
.setComponentUuid(projectUuid),
- user.getLogin(), projectName);
+ user.getLogin(), projectName, qualifier);
}
/**
String key = String.join(".", PROP_NOTIFICATION_PREFIX, dispatcher, channel);
String projectUuid = project == null ? null : project.uuid();
String projectName = project == null ? null : project.name();
+ String qualifier = project == null ? null : project.qualifier();
List<PropertyDto> existingNotification = dbClient.propertiesDao().selectByQuery(
PropertyQuery.builder()
.setKey(key)
.setUserUuid(user.getUuid())
.setValue(PROP_NOTIFICATION_VALUE)
- .setComponentUuid(projectUuid), user.getLogin(), projectName);
+ .setComponentUuid(projectUuid), user.getLogin(), projectName, qualifier);
}
private static Predicate<PropertyDto> notificationScope(@Nullable ComponentDto project) {
.map(GroupDto::getName)
.ifPresent(addedDto::setGroupName);
- dbClient.groupPermissionDao().insert(dbSession, addedDto);
+ dbClient.groupPermissionDao().insert(dbSession, addedDto, change.getProject());
return true;
}
}
private void copyPermissions(DbSession dbSession, PermissionTemplateDto template, ComponentDto project, @Nullable String projectCreatorUserUuid) {
- dbClient.groupPermissionDao().deleteByRootComponentUuid(dbSession, project.uuid(), project.name());
- dbClient.userPermissionDao().deleteProjectPermissions(dbSession, project.uuid(), project.name());
+ dbClient.groupPermissionDao().deleteByRootComponentUuid(dbSession, project);
+ dbClient.userPermissionDao().deleteProjectPermissions(dbSession, project);
List<PermissionTemplateUserDto> usersPermissions = dbClient.permissionTemplateDao().selectUserPermissionsByTemplateId(dbSession, template.getUuid());
Map<String, String> userDtoMap = dbClient.userDao().selectByUuids(dbSession, usersPermissions.stream().map(PermissionTemplateUserDto::getUserUuid).collect(Collectors.toSet()))
.setRole(gp.getPermission())
.setComponentUuid(project.uuid())
.setComponentName(project.name());
- dbClient.groupPermissionDao().insert(dbSession, dto);
+ dbClient.groupPermissionDao().insert(dbSession, dto, null);
});
List<PermissionTemplateCharacteristicDto> characteristics = dbClient.permissionTemplateCharacteristicDao().selectByTemplateUuids(dbSession, singletonList(template.getUuid()));
return false;
}
checkOtherAdminsExist(dbSession, change);
- String projectUuid = change.getProjectUuid();
- String projectName = change.getProject() == null ? null : change.getProject().name();
- if (projectUuid != null) {
+ ComponentDto project = change.getProject();
+ if (project != null) {
dbClient.userPermissionDao().deleteProjectPermission(dbSession, change.getUserId().getUuid(), change.getPermission(),
- projectUuid, projectName);
+ project);
} else {
dbClient.userPermissionDao().deleteGlobalPermission(dbSession, change.getUserId().getUuid(), change.getPermission());
}
private void updatePermissionsToPrivate(DbSession dbSession, ComponentDto component) {
// delete project permissions for group AnyOne
- dbClient.groupPermissionDao().deleteByRootComponentUuidForAnyOne(dbSession, component.uuid(), component.name());
+ dbClient.groupPermissionDao().deleteByRootComponentUuidForAnyOne(dbSession, component);
// grant UserRole.CODEVIEWER and UserRole.USER to any group or user with at least one permission on project
PUBLIC_PERMISSIONS.forEach(permission -> {
dbClient.groupPermissionDao().selectGroupUuidsWithPermissionOnProjectBut(dbSession, component.uuid(), permission)
.setGroupUuid(groupUuid)
.setGroupName(groupName)
.setRole(permission)
- .setComponentName(component.name()));
+ .setComponentName(component.name()), component);
}
private void updatePermissionsToPublic(DbSession dbSession, ComponentDto component) {
PUBLIC_PERMISSIONS.forEach(permission -> {
// delete project group permission for UserRole.CODEVIEWER and UserRole.USER
- dbClient.groupPermissionDao().deleteByRootComponentUuidAndPermission(dbSession, component.uuid(), permission, component.name());
+ dbClient.groupPermissionDao().deleteByRootComponentUuidAndPermission(dbSession, permission, component);
// delete project user permission for UserRole.CODEVIEWER and UserRole.USER
- dbClient.userPermissionDao().deleteProjectPermissionOfAnyUser(dbSession, component.uuid(), permission, component.name());
+ dbClient.userPermissionDao().deleteProjectPermissionOfAnyUser(dbSession, permission, component);
});
}
private void doHandle(DbSession dbSession, SetRequest request) {
Optional<ComponentDto> component = searchComponent(dbSession, request);
String projectName = component.isPresent() ? component.get().name() : null;
+ String qualifier = component.isPresent() ? component.get().qualifier() : null;
checkPermissions(component);
PropertyDefinition definition = propertyDefinitions.get(request.getKey());
validate(request);
PropertyDto property = toProperty(request, component);
value = property.getValue();
- dbClient.propertiesDao().saveProperty(dbSession, property, null, projectName);
+ dbClient.propertiesDao().saveProperty(dbSession, property, null, projectName, qualifier);
}
dbSession.commit();
String key = persistedKey(request);
String componentUuid = component.isPresent() ? component.get().uuid() : null;
String componentName = component.isPresent() ? component.get().name() : null;
+ String qualifier = component.isPresent() ? component.get().qualifier() : null;
deleteSettings(dbSession, component, key);
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey(key).setValue(inlinedFieldKeys)
- .setComponentUuid(componentUuid), null, componentName);
+ .setComponentUuid(componentUuid), null, componentName, qualifier);
List<String> fieldValues = request.getFieldValues();
IntStream.of(fieldIds).boxed()
.flatMap(i -> readOneFieldValues(fieldValues.get(i - 1), request.getKey()).entrySet().stream()
.map(entry -> new KeyValue(key + "." + i + "." + entry.getKey(), entry.getValue())))
.forEach(keyValue -> dbClient.propertiesDao().saveProperty(dbSession, toFieldProperty(keyValue, componentUuid),
- null, componentName));
+ null, componentName, qualifier));
return inlinedFieldKeys;
}
private void deleteSetting(DbSession dbSession, String settingKey, Optional<ComponentDto> componentDto) {
if (componentDto.isPresent()) {
- dbClient.propertiesDao().deleteProjectProperty(settingKey, componentDto.get().uuid(), dbSession, componentDto.get().name());
+ dbClient.propertiesDao().deleteProjectProperty(dbSession, settingKey, componentDto.get().uuid(), componentDto.get().name(),
+ componentDto.get().qualifier());
} else {
dbClient.propertiesDao().deleteGlobalProperty(settingKey, dbSession);
}
Stream.of(javaProject, markDownProject).forEach(this::addFavourite);
index();
- addFavourite(null, null);
+ addFavourite(null, null, null);
SearchProjectsWsResponse result = call(request.setFilter("isFavorite"));
}
private void addFavourite(ComponentDto project) {
- addFavourite(project.uuid(), project.name());
+ addFavourite(project.uuid(), project.name(), project.qualifier());
}
- private void addFavourite(@Nullable String componentUuid, @Nullable String componentName) {
+ private void addFavourite(@Nullable String componentUuid, @Nullable String componentName, @Nullable String qualifier) {
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto().setKey("favourite")
- .setComponentUuid(componentUuid).setUserUuid(userSession.getUuid()), userSession.getLogin(), componentName);
+ .setComponentUuid(componentUuid).setUserUuid(userSession.getUuid()), userSession.getLogin(), componentName, qualifier);
dbSession.commit();
}
.setGroupUuid(null)
.setComponentUuid(project.uuid())
.setComponentName(project.name())
- .setRole(permission));
+ .setRole(permission), project);
session.commit();
userSession.logIn().addProjectPermission(permission, project);
}
.setRole(perm)
.setComponentUuid(privateProject.uuid())
.setComponentName(privateProject.name());
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, privateProject);
db.commit();
}
}
.setRole(perm)
.setComponentUuid(project.uuid())
.setComponentName(project.name());
- db.getDbClient().groupPermissionDao().insert(db.getSession(), dto);
+ db.getDbClient().groupPermissionDao().insert(db.getSession(), dto, project);
db.commit();
}
}
.setRole(permission)
.setComponentUuid(component.uuid())
.setComponentName(component.name());
- dbTester.getDbClient().groupPermissionDao().insert(dbTester.getSession(), dto);
+ dbTester.getDbClient().groupPermissionDao().insert(dbTester.getSession(), dto, component);
dbTester.commit();
}
.setRole(permission)
.setComponentUuid(component.uuid())
.setComponentName(component.name());
- dbTester.getDbClient().groupPermissionDao().insert(dbTester.getSession(), dto);
+ dbTester.getDbClient().groupPermissionDao().insert(dbTester.getSession(), dto, component);
dbTester.commit();
}
public void remove_global_setting() {
logInAsSystemAdministrator();
definitions.addComponent(PropertyDefinition.builder("foo").build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
executeRequestOnGlobalSetting("foo");
assertGlobalPropertyDoesNotExist("foo");
@Test
public void remove_global_setting_even_if_not_defined() {
logInAsSystemAdministrator();
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
executeRequestOnGlobalSetting("foo");
assertGlobalPropertyDoesNotExist("foo");
public void remove_component_setting() {
logInAsProjectAdmin();
definitions.addComponent(PropertyDefinition.builder("foo").onQualifiers(PROJECT).build());
- propertyDb.insertProperties(null, null, newComponentPropertyDto(project).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newComponentPropertyDto(project).setKey("foo").setValue("value"));
executeRequestOnProjectSetting("foo");
assertProjectPropertyDoesNotExist("foo");
@Test
public void remove_component_setting_even_if_not_defined() {
logInAsProjectAdmin();
- propertyDb.insertProperties(null, null, newComponentPropertyDto(project).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newComponentPropertyDto(project).setKey("foo").setValue("value"));
executeRequestOnProjectSetting("foo");
assertProjectPropertyDoesNotExist("foo");
public void remove_hidden_setting() {
logInAsSystemAdministrator();
definitions.addComponent(PropertyDefinition.builder("foo").hidden().build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
executeRequestOnGlobalSetting("foo");
assertGlobalPropertyDoesNotExist("foo");
@Test
public void ignore_project_setting_when_removing_global_setting() {
logInAsSystemAdministrator();
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
executeRequestOnGlobalSetting("foo");
@Test
public void ignore_global_setting_when_removing_project_setting() {
logInAsProjectAdmin();
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
executeRequestOnProjectSetting("foo");
public void ignore_user_setting_when_removing_global_setting() {
logInAsSystemAdministrator();
UserDto user = dbClient.userDao().insert(dbSession, UserTesting.newUserDto());
- propertyDb.insertProperties(user.getLogin(), null, newUserPropertyDto("foo", "one", user));
+ propertyDb.insertProperties(user.getLogin(), null, null, newUserPropertyDto("foo", "one", user));
executeRequestOnGlobalSetting("foo");
assertUserPropertyExists("foo", user);
public void ignore_user_setting_when_removing_project_setting() {
logInAsProjectAdmin();
UserDto user = dbClient.userDao().insert(dbSession, UserTesting.newUserDto());
- propertyDb.insertProperties(user.getLogin(), null, newUserPropertyDto("foo", "one", user));
+ propertyDb.insertProperties(user.getLogin(), null, null, newUserPropertyDto("foo", "one", user));
executeRequestOnProjectSetting("foo");
assertUserPropertyExists("foo", user);
public void remove_setting_by_deprecated_key() {
logInAsSystemAdministrator();
definitions.addComponent(PropertyDefinition.builder("foo").deprecatedKey("old").build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
executeRequestOnGlobalSetting("old");
assertGlobalPropertyDoesNotExist("foo");
ComponentDto project = db.components().insertPublicProject();
ComponentDto branch = db.components().insertProjectBranch(project);
definitions.addComponent(PropertyDefinition.builder("foo").onQualifiers(PROJECT).build());
- propertyDb.insertProperties(null, branch.name(), newComponentPropertyDto(branch).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, branch.name(), null, newComponentPropertyDto(branch).setKey("foo").setValue("value"));
userSession.logIn().addProjectPermission(ADMIN, project);
ws.newRequest()
@Test
public void update_existing_global_setting() {
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my value"), null, null);
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my value"), null, null, null);
assertGlobalSetting("my.key", "my value");
callForGlobalSetting("my.key", "my new value");
@Test
public void persist_new_project_setting() {
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null);
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null, null);
ComponentDto project = db.components().insertPrivateProject();
logInAsProjectAdministrator(project);
@Test
public void update_existing_project_setting() {
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null);
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null, null);
ComponentDto project = db.components().insertPrivateProject();
- propertyDb.insertProperty(newComponentPropertyDto("my.key", "my project value", project), project.name(), null);
+ propertyDb.insertProperty(newComponentPropertyDto("my.key", "my project value", project), project.name(), null, null);
assertComponentSetting("my.key", "my project value", project.uuid());
logInAsProjectAdministrator(project);
.type(PropertyType.STRING)
.build()))
.build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto("my.key", "1,2,3,4"),
newGlobalPropertyDto("my.key.1.firstField", "oldFirstValue"),
newGlobalPropertyDto("my.key.1.secondField", "oldSecondValue"),
.build()))
.build());
ComponentDto project = db.components().insertPrivateProject();
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto("my.key", "1"),
newGlobalPropertyDto("my.key.1.firstField", "oldFirstValue"),
newGlobalPropertyDto("my.key.1.secondField", "oldSecondValue"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto("my.key", "1", project),
newComponentPropertyDto("my.key.1.firstField", "componentFirstValue", project),
newComponentPropertyDto("my.key.1.firstField", "componentSecondValue", project));
@Test
public void user_setting_is_not_updated() {
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my user value").setUserUuid("42"), null, "user_login");
- propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null);
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my user value").setUserUuid("42"), null, null, "user_login");
+ propertyDb.insertProperty(newGlobalPropertyDto("my.key", "my global value"), null, null, null);
callForGlobalSetting("my.key", "my new global value");
@Test
public void delete_global_settings() {
definitions.addComponent(PropertyDefinition.builder("foo").build());
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("bar").setValue("two"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(), newComponentPropertyDto(project).setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("bar").setValue("two"));
underTest.deleteGlobalSettings(dbSession, "foo", "bar");
@Test
public void delete_component_settings() {
definitions.addComponent(PropertyDefinition.builder("foo").build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("value"));
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("foo").setValue("one"));
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("bar").setValue("two"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("value"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(), newComponentPropertyDto(project).setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(), newComponentPropertyDto(project).setKey("bar").setValue("two"));
underTest.deleteComponentSettings(dbSession, project, "foo", "bar");
@Test
public void does_not_fail_when_deleting_unknown_setting() {
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
underTest.deleteGlobalSettings(dbSession, "unknown");
@Test
public void does_not_delete_user_settings() {
UserDto user = dbClient.userDao().insert(dbSession, UserTesting.newUserDto());
- propertyDb.insertProperties(user.getLogin(), null, newUserPropertyDto("foo", "one", user));
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(user.getLogin(), null, null, newUserPropertyDto("foo", "one", user));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
underTest.deleteGlobalSettings(dbSession, "foo");
PropertyFieldDefinition.build("key").name("Key").build(),
PropertyFieldDefinition.build("size").name("Size").build()))
.build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("1,2"),
newGlobalPropertyDto().setKey("foo.1.key").setValue("key1"),
newGlobalPropertyDto().setKey("foo.1.size").setValue("size1"),
PropertyFieldDefinition.build("key").name("Key").build(),
PropertyFieldDefinition.build("size").name("Size").build()))
.build());
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("1,2"),
newComponentPropertyDto(project).setKey("foo.1.key").setValue("key1"),
newComponentPropertyDto(project).setKey("foo.1.size").setValue("size1"),
PropertyFieldDefinition.build("key").name("Key").build(),
PropertyFieldDefinition.build("size").name("Size").build()))
.build());
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("other").setValue("1,2"),
newComponentPropertyDto(project).setKey("other.1.key").setValue("key1"));
definitions.addComponent(PropertyDefinition
.builder("foo")
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
ValuesWsResponse result = executeRequestForGlobalProperties("foo");
definitions.addComponent(PropertyDefinition.builder("global")
.multiValues(true)
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("global").setValue("three,four"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("global").setValue("three,four"));
ValuesWsResponse result = executeRequestForGlobalProperties("default", "global");
assertThat(result.getSettingsList()).hasSize(2);
public void return_multi_value_with_coma() {
logIn();
definitions.addComponent(PropertyDefinition.builder("global").multiValues(true).build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("global").setValue("three,four%2Cfive"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("global").setValue("three,four%2Cfive"));
ValuesWsResponse result = executeRequestForGlobalProperties("global");
public void return_global_values() {
logIn();
definitions.addComponent(PropertyDefinition.builder("property").defaultValue("default").build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
// The property is overriding default value
newGlobalPropertyDto().setKey("property").setValue("one"));
logInAsProjectUser();
definitions.addComponent(
PropertyDefinition.builder("property").defaultValue("default").onQualifiers(PROJECT).build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("property").setValue("one"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
// The property is overriding global value
newComponentPropertyDto(project).setKey("property").setValue("two"));
PropertyDefinition.builder("global").build(),
PropertyDefinition.builder("global.default").defaultValue("default").build(),
PropertyDefinition.builder("project").onQualifiers(PROJECT).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("global").setValue("one"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("project").setValue("two"));
ValuesWsResponse result = executeRequestForProjectProperties();
logInAsProjectUser();
definitions.addComponent(PropertyDefinition.builder("property").defaultValue("default").onQualifiers(PROJECT).build());
// The property is not defined on project
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("property").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("property").setValue("one"));
ValuesWsResponse result = executeRequestForProjectProperties("property");
@Test
public void return_values_even_if_no_property_definition() {
logIn();
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("globalPropertyWithoutDefinition").setValue("value"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("globalPropertyWithoutDefinition").setValue("value"));
ValuesWsResponse result = executeRequestForGlobalProperties("globalPropertyWithoutDefinition");
@Test
public void return_values_of_component_even_if_no_property_definition() {
logInAsProjectUser();
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("property").setValue("foo"));
ValuesWsResponse response = executeRequestForComponentProperties(project, "property");
.builder("foo")
.defaultValue("default")
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("bar").setValue(""));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("bar").setValue(""));
ValuesWsResponse result = executeRequestForGlobalProperties("unknown");
logInAsProjectUser();
ComponentDto module = componentDb.insertComponent(newModuleDto(project));
definitions.addComponent(PropertyDefinition.builder("property").defaultValue("default").onQualifiers(PROJECT, MODULE).build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("property").setValue("one"));
- propertyDb.insertProperties(null, module.name(),
+ propertyDb.insertProperties(null, module.name(), module.qualifier(),
// The property is overriding global value
newComponentPropertyDto(module).setKey("property").setValue("two"));
PropertyDefinition.builder("globalProperty").onQualifiers(PROJECT, MODULE).build(),
PropertyDefinition.builder("projectProperty").onQualifiers(PROJECT, MODULE).build(),
PropertyDefinition.builder("moduleProperty").onQualifiers(PROJECT, MODULE).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("globalProperty").setValue("global"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("projectProperty").setValue("project"));
- propertyDb.insertProperties(null, module.name(),
+ propertyDb.insertProperties(null, module.name(), module.qualifier(),
newComponentPropertyDto(module).setKey("moduleProperty").setValue("module"));
ValuesWsResponse result = executeRequestForComponentProperties(module, "defaultProperty", "globalProperty", "projectProperty", "moduleProperty");
definitions.addComponents(asList(
PropertyDefinition.builder("defaultProperty").defaultValue("default").build(),
PropertyDefinition.builder("globalProperty").build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("globalProperty").setValue("global"));
ValuesWsResponse result = executeRequestForGlobalProperties("defaultProperty", "globalProperty");
ComponentDto subModule = componentDb.insertComponent(newModuleDto(module));
definitions.addComponents(asList(
PropertyDefinition.builder("foo").defaultValue("default").onQualifiers(PROJECT, MODULE).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("global"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("project"));
- propertyDb.insertProperties(null, module.name(),
+ propertyDb.insertProperties(null, module.name(), module.qualifier(),
newComponentPropertyDto(module).setKey("foo").setValue("module"));
assertParentValue(executeRequestForComponentProperties(subModule, "foo").getSettings(0), "module");
ComponentDto subModule = componentDb.insertComponent(newModuleDto(module));
definitions.addComponents(asList(
PropertyDefinition.builder("foo").defaultValue("default1,default2").multiValues(true).onQualifiers(PROJECT, MODULE).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("global1,global2"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("project1,project2"));
- propertyDb.insertProperties(null, module.name(),
+ propertyDb.insertProperties(null, module.name(), module.qualifier(),
newComponentPropertyDto(module).setKey("foo").setValue("module1,module2"));
assertParentValues(executeRequestForComponentProperties(subModule, "foo").getSettings(0), "module1", "module2");
PropertyFieldDefinition.build("key").name("Key").build(),
PropertyFieldDefinition.build("size").name("Size").build()))
.build()));
- propertyDb.insertProperties(null, module.name(),
+ propertyDb.insertProperties(null, module.name(), module.qualifier(),
newComponentPropertyDto(module).setKey("simple").setValue("module"),
newComponentPropertyDto(module).setKey("multi").setValue("module1,module2"));
propertyDb.insertPropertySet("set", module, ImmutableMap.of("key", "keyM1", "size", "sizeM1"));
public void return_parent_value_when_no_definition() {
logInAsProjectUser();
ComponentDto module = componentDb.insertComponent(newModuleDto(project));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("global"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("project"));
assertParentValue(executeRequestForComponentProperties(module, "foo").getSettings(0), "project");
.builder("foo")
.deprecatedKey("deprecated")
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
ValuesWsResponse result = executeRequestForGlobalProperties("deprecated");
definitions.addComponents(asList(
PropertyDefinition.builder("foo").build(),
PropertyDefinition.builder("secret.secured").build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("one"),
newGlobalPropertyDto().setKey("secret.secured").setValue("password"));
definitions.addComponents(asList(
PropertyDefinition.builder("foo").build(),
PropertyDefinition.builder("secret.secured").build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("one"),
newGlobalPropertyDto().setKey("secret.secured").setValue("password"));
PropertyDefinition.builder("foo").onQualifiers(PROJECT).build(),
PropertyDefinition.builder("global.secret.secured").build(),
PropertyDefinition.builder("secret.secured").onQualifiers(PROJECT).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("global.secret.secured").setValue("very secret"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("one"),
newComponentPropertyDto(project).setKey("secret.secured").setValue("password"));
userSession
.addProjectPermission(USER, project)
.addProjectPermission(SCAN_EXECUTION, project);
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("not-defined.secured").setValue("123"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
+ newComponentPropertyDto(project).setKey("not-defined.secured").setValue("123"));
ValuesWsResponse result = executeRequestForProjectProperties("not-defined.secured");
definitions.addComponents(asList(
PropertyDefinition.builder("foo").build(),
PropertyDefinition.builder("secret.secured").build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("one"),
newGlobalPropertyDto().setKey("secret.secured").setValue("password"));
PropertyDefinition.builder("foo").onQualifiers(PROJECT).build(),
PropertyDefinition.builder("global.secret.secured").build(),
PropertyDefinition.builder("secret.secured").onQualifiers(PROJECT).build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("global.secret.secured").setValue("very secret"));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("one"),
newComponentPropertyDto(project).setKey("secret.secured").setValue("password"));
@Test
public void return_secured_settings_even_if_not_defined_when_project_admin() {
logInAsProjectAdmin();
- propertyDb.insertProperties(null, project.name(), newComponentPropertyDto(project).setKey("not-defined.secured").setValue("123"));
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
+ newComponentPropertyDto(project).setKey("not-defined.secured").setValue("123"));
ValuesWsResponse result = executeRequestForProjectProperties("not-defined.secured");
definitions.addComponents(asList(
PropertyDefinition.builder("foo").build(),
PropertyDefinition.builder("secret.secured").build()));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("foo").setValue("one"),
newGlobalPropertyDto().setKey("secret.secured").setValue("password"));
definitions.addComponents(asList(
PropertyDefinition.builder("foo").onQualifiers(PROJECT).build(),
PropertyDefinition.builder("secret.secured").onQualifiers(PROJECT).build()));
- propertyDb.insertProperties(null, project.name(),
+ propertyDb.insertProperties(null, project.name(), project.qualifier(),
newComponentPropertyDto(project).setKey("foo").setValue("one"),
newComponentPropertyDto(project).setKey("secret.secured").setValue("password"));
public void return_additional_settings_specific_for_scanner_when_no_keys() {
logInAsAdmin();
definitions.addComponent(PropertyDefinition.builder("secret.secured").build());
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey("sonar.core.id").setValue("ID"),
newGlobalPropertyDto().setKey("sonar.core.startTime").setValue("2017-01-01"));
definitions.addComponent(PropertyDefinition
.builder("foo")
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("fi±∞…"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("fi±∞…"));
ValuesWsResponse result = executeRequestForGlobalProperties("foo");
.builder("foo")
.deprecatedKey("deprecated")
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("foo").setValue("one"));
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("'foo' and 'deprecated' cannot be used at the same time as they refer to the same setting");
.builder("sonar.autogenerated")
.multiValues(true)
.build());
- propertyDb.insertProperties(null, null, newGlobalPropertyDto().setKey("sonar.autogenerated").setValue("val1,val2,val3"));
+ propertyDb.insertProperties(null, null, null, newGlobalPropertyDto().setKey("sonar.autogenerated").setValue("val1,val2,val3"));
definitions.addComponent(PropertyDefinition
.builder("sonar.demo")
.type(PropertyType.PROPERTY_SET)
PropertyDefinition securedDef = PropertyDefinition.builder("my.password.secured").build();
PropertyDefinition standardDef = PropertyDefinition.builder("my.property").build();
definitions.addComponents(asList(securedDef, standardDef));
- propertyDb.insertProperties(null, null,
+ propertyDb.insertProperties(null, null, null,
newGlobalPropertyDto().setKey(securedDef.key()).setValue("securedValue"),
newGlobalPropertyDto().setKey(standardDef.key()).setValue("standardValue"));
ComponentDto project = insertProject();
UserDto user = db.users().insertUser("obiwan");
propertyDbTester.insertProperty(new PropertyDto().setKey("favourite").setComponentUuid(project.uuid()).setUserUuid(user.getUuid()),
- project.name(), user.getLogin());
+ project.name(), project.qualifier(), user.getLogin());
userSession.logIn(user).addProjectPermission(UserRole.USER, project);
init();
ComponentDto branch = componentDbTester.insertProjectBranch(project, b -> b.setKey("feature1").setUuid("xyz"));
UserDto user = db.users().insertUser("obiwan");
propertyDbTester.insertProperty(new PropertyDto().setKey("favourite").setComponentUuid(project.uuid()).setUserUuid(user.getUuid()),
- project.name(), user.getLogin());
+ project.name(), project.qualifier(), user.getLogin());
userSession.logIn(user).addProjectPermission(UserRole.USER, project);
init();
when(resourceTypes.get(project.qualifier())).thenReturn(DefaultResourceTypes.get().getRootType());
UserDto user = db.users().insertUser("obiwan");
propertyDbTester.insertProperty(new PropertyDto().setKey("favourite").setComponentUuid(project.uuid()).setUserUuid(user.getUuid()),
- project.name(), user.getLogin());
+ project.name(), project.qualifier(), user.getLogin());
addQualityProfiles(project,
createQProfile("qp1", "Sonar Way Java", "java"),
createQProfile("qp2", "Sonar Way Xoo", "xoo"));
logInAsSystemAdministrator();
UserDto user = db.users().insertUser();
ComponentDto project = db.components().insertPrivateProject();
- db.properties().insertProperty(newUserPropertyDto(user), null, user.getLogin());
- db.properties().insertProperty(newUserPropertyDto(user), null, user.getLogin());
- db.properties().insertProperty(newUserPropertyDto(user).setComponentUuid(project.uuid()), project.name(), user.getLogin());
+ db.properties().insertProperty(newUserPropertyDto(user), null, null, user.getLogin());
+ db.properties().insertProperty(newUserPropertyDto(user), null, null, user.getLogin());
+ db.properties().insertProperty(newUserPropertyDto(user).setComponentUuid(project.uuid()), project.name(), project.qualifier(), user.getLogin());
deactivate(user.getLogin());
ComponentDto project = db.components().insertPrivateProject();
ComponentDto anotherProject = db.components().insertPrivateProject();
db.properties().insertProperty(new PropertyDto().setKey("sonar.issues.defaultAssigneeLogin").setValue(user.getLogin())
- .setComponentUuid(project.uuid()), project.name(), user.getLogin());
+ .setComponentUuid(project.uuid()), project.name(), project.qualifier(), user.getLogin());
db.properties().insertProperty(new PropertyDto().setKey("sonar.issues.defaultAssigneeLogin").setValue(user.getLogin())
- .setComponentUuid(anotherProject.uuid()), anotherProject.name(), user.getLogin());
+ .setComponentUuid(anotherProject.uuid()), anotherProject.name(), anotherProject.qualifier(), user.getLogin());
db.properties().insertProperty(new PropertyDto().setKey("other").setValue(user.getLogin())
- .setComponentUuid(anotherProject.uuid()), anotherProject.name(), user.getLogin());
+ .setComponentUuid(anotherProject.uuid()), anotherProject.name(), anotherProject.qualifier(), user.getLogin());
deactivate(user.getLogin());
projects / sonarqube.git / commitdiff