source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2023 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 package org.sonar.server.telemetry;
  21
  22 import com.tngtech.java.junit.dataprovider.DataProvider;
  23 import com.tngtech.java.junit.dataprovider.DataProviderRunner;
  24 import com.tngtech.java.junit.dataprovider.UseDataProvider;
  25 import java.io.StringWriter;
  26 import java.util.Arrays;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.Locale;
  30 import java.util.Map;
  31 import java.util.Random;
  32 import java.util.Set;
  33 import java.util.stream.Collectors;
  34 import java.util.stream.IntStream;
  35 import org.apache.commons.codec.digest.DigestUtils;
  36 import org.jetbrains.annotations.NotNull;
  37 import org.junit.Test;
  38 import org.junit.runner.RunWith;
  39 import org.sonar.api.utils.System2;
  40 import org.sonar.api.utils.text.JsonWriter;
  41 import org.sonar.core.platform.EditionProvider;
  42 import org.sonar.core.telemetry.TelemetryExtension;
  43 import org.sonar.core.util.stream.MoreCollectors;
  44 import org.sonar.db.user.UserTelemetryDto;
  45
  46 import static java.lang.String.format;
  47 import static java.util.stream.Collectors.joining;
  48 import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
  49 import static org.assertj.core.api.Assertions.assertThat;
  50 import static org.mockito.Mockito.mock;
  51 import static org.mockito.Mockito.when;
  52 import static org.sonar.server.telemetry.TelemetryDataJsonWriter.SCIM_PROPERTY;
  53 import static org.sonar.test.JsonAssert.assertJson;
  54
  55 @RunWith(DataProviderRunner.class)
  56 public class TelemetryDataJsonWriterTest {
  57
  58   private final Random random = new Random();
  59
  60   private final TelemetryExtension extension = mock(TelemetryExtension.class);
  61
  62   private final System2 system2 = mock(System2.class);
  63
  64   private final TelemetryDataJsonWriter underTest = new TelemetryDataJsonWriter(List.of(extension), system2);
  65
  66   @Test
  67   public void write_server_id_version_and_sequence() {
  68     TelemetryData data = telemetryBuilder().build();
  69
  70     String json = writeTelemetryData(data);
  71     assertJson(json).isSimilarTo("""
  72       {
  73         "id": "%s",
  74         "version": "%s",
  75         "messageSequenceNumber": %s
  76       }
  77       """.formatted(data.getServerId(), data.getVersion(), data.getMessageSequenceNumber()));
  78   }
  79
  80   @Test
  81   public void does_not_write_edition_if_null() {
  82     TelemetryData data = telemetryBuilder().build();
  83
  84     String json = writeTelemetryData(data);
  85
  86     assertThat(json).doesNotContain("edition");
  87   }
  88
  89   @Test
  90   @UseDataProvider("allEditions")
  91   public void writes_edition_if_non_null(EditionProvider.Edition edition) {
  92     TelemetryData data = telemetryBuilder()
  93       .setEdition(edition)
  94       .build();
  95
  96     String json = writeTelemetryData(data);
  97     assertJson(json).isSimilarTo("""
  98       {
  99         "edition": "%s"
 100       }
 101       """.formatted(edition.name().toLowerCase(Locale.ENGLISH)));
 102   }
 103
 104   @Test
 105   public void writes_default_qg() {
 106     TelemetryData data = telemetryBuilder()
 107       .setDefaultQualityGate("default-qg")
 108       .build();
 109
 110     String json = writeTelemetryData(data);
 111     assertJson(json).isSimilarTo("""
 112       {
 113         "defaultQualityGate": "%s"
 114       }
 115       """.formatted(data.getDefaultQualityGate()));
 116   }
 117
 118   @Test
 119   public void writes_database() {
 120     String name = randomAlphabetic(12);
 121     String version = randomAlphabetic(10);
 122     TelemetryData data = telemetryBuilder()
 123       .setDatabase(new TelemetryData.Database(name, version))
 124       .build();
 125
 126     String json = writeTelemetryData(data);
 127     assertJson(json).isSimilarTo("""
 128       {
 129         "database": {
 130           "name": "%s",
 131           "version": "%s"
 132         }
 133       }
 134       """.formatted(name, version));
 135   }
 136
 137   @Test
 138   public void writes_no_plugins() {
 139     TelemetryData data = telemetryBuilder()
 140       .setPlugins(Collections.emptyMap())
 141       .build();
 142
 143     String json = writeTelemetryData(data);
 144
 145     assertJson(json).isSimilarTo("""
 146       {
 147         "plugins": []
 148       }
 149       """);
 150   }
 151
 152   @Test
 153   public void writes_all_plugins() {
 154     Map<String, String> plugins = IntStream.range(0, 1 + random.nextInt(10))
 155       .boxed()
 156       .collect(MoreCollectors.uniqueIndex(i -> "P" + i, i -> "V" + i));
 157     TelemetryData data = telemetryBuilder()
 158       .setPlugins(plugins)
 159       .build();
 160
 161     String json = writeTelemetryData(data);
 162     assertJson(json).isSimilarTo("""
 163       {
 164         "plugins": [%s]
 165       }
 166       """.formatted(plugins.entrySet().stream().map(e -> "{\"name\":\"" + e.getKey() + "\",\"version\":\"" + e.getValue() + "\"}").collect(joining(","))));
 167   }
 168
 169   @Test
 170   public void does_not_write_installation_date_if_null() {
 171     TelemetryData data = telemetryBuilder()
 172       .setInstallationDate(null)
 173       .build();
 174
 175     String json = writeTelemetryData(data);
 176
 177     assertThat(json).doesNotContain("installationDate");
 178   }
 179
 180   @Test
 181   public void write_installation_date_in_utc_format() {
 182     TelemetryData data = telemetryBuilder()
 183       .setInstallationDate(1_000L)
 184       .build();
 185
 186     String json = writeTelemetryData(data);
 187
 188     assertJson(json).isSimilarTo("""
 189       {
 190         "installationDate":"1970-01-01T00:00:01+0000"
 191       }
 192       """);
 193   }
 194
 195   @Test
 196   public void does_not_write_installation_version_if_null() {
 197     TelemetryData data = telemetryBuilder()
 198       .setInstallationVersion(null)
 199       .build();
 200
 201     String json = writeTelemetryData(data);
 202
 203     assertThat(json).doesNotContain("installationVersion");
 204   }
 205
 206   @Test
 207   public void write_installation_version() {
 208     String installationVersion = randomAlphabetic(5);
 209     TelemetryData data = telemetryBuilder()
 210       .setInstallationVersion(installationVersion)
 211       .build();
 212
 213     String json = writeTelemetryData(data);
 214     assertJson(json).isSimilarTo("""
 215       {
 216         "installationVersion": "%s"
 217       }
 218       """.formatted(installationVersion));
 219   }
 220
 221   @Test
 222   @UseDataProvider("getFeatureFlagEnabledStates")
 223   public void write_docker_flag(boolean isInDocker) {
 224     TelemetryData data = telemetryBuilder()
 225       .setInDocker(isInDocker)
 226       .build();
 227
 228     String json = writeTelemetryData(data);
 229     assertJson(json).isSimilarTo("""
 230       {
 231         "docker": %s
 232       }
 233       """.formatted(isInDocker));
 234   }
 235
 236   @Test
 237   @UseDataProvider("getFeatureFlagEnabledStates")
 238   public void write_scim_feature_flag(boolean isScimEnabled) {
 239     TelemetryData data = telemetryBuilder()
 240       .setIsScimEnabled(isScimEnabled)
 241       .build();
 242
 243     String json = writeTelemetryData(data);
 244
 245     assertJson(json).isSimilarTo("{" + format("  \"%s\":", SCIM_PROPERTY) + isScimEnabled + "}");
 246   }
 247
 248   @Test
 249   public void writes_has_unanalyzed_languages() {
 250     TelemetryData data = telemetryBuilder()
 251       .setHasUnanalyzedC(true)
 252       .setHasUnanalyzedCpp(false)
 253       .build();
 254
 255     String json = writeTelemetryData(data);
 256
 257     assertJson(json).isSimilarTo("""
 258       {
 259         "hasUnanalyzedC": true,
 260         "hasUnanalyzedCpp": false,
 261       }
 262       """);
 263   }
 264
 265   @Test
 266   public void writes_security_custom_config() {
 267     TelemetryData data = telemetryBuilder()
 268       .setCustomSecurityConfigs(Set.of("php", "java"))
 269       .build();
 270
 271     String json = writeTelemetryData(data);
 272
 273     assertJson(json).isSimilarTo("""
 274       {
 275         "customSecurityConfig": ["php", "java"]
 276       }
 277       """);
 278   }
 279
 280   @Test
 281   public void writes_local_timestamp() {
 282     when(system2.now()).thenReturn(1000L);
 283
 284     TelemetryData data = telemetryBuilder().build();
 285     String json = writeTelemetryData(data);
 286
 287     assertJson(json).isSimilarTo("""
 288       {
 289         "localTimestamp": "1970-01-01T00:00:01+0000"
 290       }
 291       """);
 292   }
 293
 294   @Test
 295   public void writes_all_users_with_anonymous_md5_uuids() {
 296     TelemetryData data = telemetryBuilder()
 297       .setUsers(attachUsers())
 298       .build();
 299
 300     String json = writeTelemetryData(data);
 301
 302     assertJson(json).isSimilarTo("""
 303       {
 304         "users": [
 305           {
 306             "userUuid": "%s",
 307             "status": "active",
 308             "identityProvider": "gitlab",
 309             "lastActivity": "1970-01-01T00:00:00+0000",
 310             "lastSonarlintActivity": "1970-01-01T00:00:00+0000"
 311           },
 312           {
 313             "userUuid": "%s",
 314             "status": "inactive",
 315             "identityProvider": "gitlab",
 316             "lastActivity": "1970-01-01T00:00:00+0000",
 317             "lastSonarlintActivity": "1970-01-01T00:00:00+0000"
 318           },
 319           {
 320             "userUuid": "%s",
 321             "status": "active",
 322             "identityProvider": "gitlab",
 323             "lastActivity": "1970-01-01T00:00:00+0000",
 324             "lastSonarlintActivity": "1970-01-01T00:00:00+0000"
 325           }
 326         ]
 327       }
 328       """
 329       .formatted(DigestUtils.sha3_224Hex("uuid-0"), DigestUtils.sha3_224Hex("uuid-1"), DigestUtils.sha3_224Hex("uuid-2")));
 330   }
 331
 332   @Test
 333   public void writes_all_projects() {
 334     TelemetryData data = telemetryBuilder()
 335       .setProjects(attachProjects())
 336       .build();
 337
 338     String json = writeTelemetryData(data);
 339
 340     assertJson(json).isSimilarTo("""
 341       {
 342         "projects": [
 343           {
 344             "projectUuid": "uuid-0",
 345             "lastAnalysis": "1970-01-01T00:00:00+0000",
 346             "language": "lang-0",
 347             "loc": 2
 348           },
 349           {
 350             "projectUuid": "uuid-1",
 351             "lastAnalysis": "1970-01-01T00:00:00+0000",
 352             "language": "lang-1",
 353             "loc": 4
 354           },
 355           {
 356             "projectUuid": "uuid-2",
 357             "lastAnalysis": "1970-01-01T00:00:00+0000",
 358             "language": "lang-2",
 359             "loc": 6
 360           }
 361         ]
 362       }
 363       """);
 364   }
 365
 366   @Test
 367   public void writes_all_projects_stats_with_analyzed_languages() {
 368     TelemetryData data = telemetryBuilder()
 369       .setProjectStatistics(attachProjectStats())
 370       .build();
 371
 372     String json = writeTelemetryData(data);
 373
 374     assertJson(json).isSimilarTo("""
 375       {
 376         "projects-general-stats": [
 377           {
 378             "projectUuid": "uuid-0",
 379             "branchCount": 2,
 380             "pullRequestCount": 2,
 381             "qualityGate": "qg-0"
 382             "scm": "scm-0",
 383             "ci": "ci-0",
 384             "devopsPlatform": "devops-0"
 385           },
 386           {
 387             "projectUuid": "uuid-1",
 388             "branchCount": 4,
 389             "pullRequestCount": 4,
 390             "qualityGate": "qg-1"
 391             "scm": "scm-1",
 392             "ci": "ci-1",
 393             "devopsPlatform": "devops-1"
 394           },
 395           {
 396             "projectUuid": "uuid-2",
 397             "branchCount": 6,
 398             "pullRequestCount": 6,
 399             "qualityGate": "qg-2"
 400             "scm": "scm-2",
 401             "ci": "ci-2",
 402             "devopsPlatform": "devops-2"
 403           }
 404         ]
 405       }
 406       """
 407     );
 408   }
 409
 410   @Test
 411   public void writes_all_projects_stats_with_unanalyzed_languages() {
 412     TelemetryData data = telemetryBuilder()
 413       .setProjectStatistics(attachProjectStats())
 414       .build();
 415
 416     String json = writeTelemetryData(data);
 417     assertThat(json).doesNotContain("hasUnanalyzedC", "hasUnanalyzedCpp");
 418   }
 419
 420   @Test
 421   public void writes_all_quality_gates() {
 422     TelemetryData data = telemetryBuilder()
 423       .setQualityGates(attachQualityGates())
 424       .build();
 425
 426     String json = writeTelemetryData(data);
 427     assertJson(json).isSimilarTo("""
 428       {
 429         "quality-gates": [
 430           {
 431             "uuid": "uuid-0",
 432             "isCaycCompliant": true
 433           },
 434           {
 435             "uuid": "uuid-1",
 436             "isCaycCompliant": false
 437           },
 438           {
 439             "uuid": "uuid-2",
 440             "isCaycCompliant": true
 441           }
 442         ]
 443       }
 444       """
 445     );
 446   }
 447
 448   private static TelemetryData.Builder telemetryBuilder() {
 449     return TelemetryData.builder()
 450       .setServerId("foo")
 451       .setVersion("bar")
 452       .setMessageSequenceNumber(1L)
 453       .setPlugins(Collections.emptyMap())
 454       .setDatabase(new TelemetryData.Database("H2", "11"));
 455   }
 456
 457   @NotNull
 458   private static List<UserTelemetryDto> attachUsers() {
 459     return IntStream.range(0, 3)
 460       .mapToObj(
 461         i -> new UserTelemetryDto().setUuid("uuid-" + i).setActive(i % 2 == 0).setLastConnectionDate(1L).setLastSonarlintConnectionDate(2L).setExternalIdentityProvider("gitlab"))
 462       .collect(Collectors.toList());
 463   }
 464
 465   private static List<TelemetryData.Project> attachProjects() {
 466     return IntStream.range(0, 3).mapToObj(i -> new TelemetryData.Project("uuid-" + i, 1L, "lang-" + i, (i + 1L) * 2L)).collect(Collectors.toList());
 467   }
 468
 469   private List<TelemetryData.ProjectStatistics> attachProjectStats() {
 470     return IntStream.range(0, 3).mapToObj(i -> new TelemetryData.ProjectStatistics("uuid-" + i, (i + 1L) * 2L, (i + 1L) * 2L, "qg-" + i, "scm-" + i, "ci-" + i, "devops-" + i))
 471       .collect(Collectors.toList());
 472   }
 473
 474   private List<TelemetryData.QualityGate> attachQualityGates() {
 475     return IntStream.range(0, 3).mapToObj(i -> new TelemetryData.QualityGate("uuid-" + i, i % 2 == 0))
 476       .collect(Collectors.toList());
 477   }
 478
 479   @DataProvider
 480   public static Object[][] allEditions() {
 481     return Arrays.stream(EditionProvider.Edition.values())
 482       .map(t -> new Object[] {t})
 483       .toArray(Object[][]::new);
 484   }
 485
 486   private String writeTelemetryData(TelemetryData data) {
 487     StringWriter jsonString = new StringWriter();
 488     try (JsonWriter json = JsonWriter.of(jsonString)) {
 489       underTest.writeTelemetryData(json, data);
 490     }
 491     return jsonString.toString();
 492   }
 493
 494   @DataProvider
 495   public static Set<Boolean> getFeatureFlagEnabledStates() {
 496     return Set.of(true, false);
 497   }
 498 }