Merge branch 'master' into dpebot-repositorygardener

Author: dzlier-gcp

monitoring/v3/pom.xml

@@ -27,7 +27,7 @@
     <parent>
         <groupId>com.google.cloud.samples</groupId>
         <artifactId>shared-configuration</artifactId>
-        <version>1.0.9</version>
+        <version>1.0.10</version>
     </parent>
 
     <properties>
@@ -46,5 +46,13 @@
             <artifactId>commons-cli</artifactId>
             <version>1.4</version>
         </dependency>
+
+        <!-- Test dependencies -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

monitoring/v3/src/main/java/AlertSample.java

@@ -42,7 +42,6 @@
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.PrintStream;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -105,7 +104,8 @@ public class AlertSample {
       "backup", BACKUP_OPTIONS,
       "restore", BACKUP_OPTIONS,
       "replace-channels", REPLACE_CHANNELS_OPTIONS,
-      "enable", ENABLE_OPTIONS
+      "enable", ENABLE_OPTIONS,
+      "disable", ENABLE_OPTIONS
   );
 
   private static final CommandLineParser PARSER = new DefaultParser();
@@ -122,26 +122,23 @@ public class AlertSample {
 
   private AlertPolicyServiceClient alertPolicyClient;
   private NotificationChannelServiceClient notificationChannelClient;
-  private PrintStream outputStream;
   private Gson gson = new Gson();
 
   private AlertSample() throws IOException {
-    this(AlertPolicyServiceClient.create(), NotificationChannelServiceClient.create(), System.out);
+    this(AlertPolicyServiceClient.create(), NotificationChannelServiceClient.create());
   }
 
   AlertSample(AlertPolicyServiceClient alertPolicyClient,
-              NotificationChannelServiceClient notificationChannelClient,
-              PrintStream os) {
+              NotificationChannelServiceClient notificationChannelClient) {
     this.alertPolicyClient = checkNotNull(alertPolicyClient);
     this.notificationChannelClient = notificationChannelClient;
-    outputStream = checkNotNull(os);
   }
 
   public static void main(String[] args) throws IOException {
     AlertSample sample = createAlertSample();
 
     if (args.length == 0) {
-      usage(System.out, null);
+      usage(null);
       return;
     }
     String command = args[0];
@@ -151,16 +148,15 @@ public static void main(String[] args) throws IOException {
 
     String projectId = cl.hasOption(PROJECT_ID_OPTION.getOpt())
         ? cl.getOptionValue(PROJECT_ID_OPTION.getOpt())
-        : System.getenv("GOOGLE_PROJECT_ID");
+        : System.getenv("GOOGLE_CLOUD_PROJECT");
 
     if (Strings.isNullOrEmpty(projectId)) {
       projectId = System.getenv("DEVSHELL_PROJECT_ID");
     }
 
     if (Strings.isNullOrEmpty(projectId)) {
-      usage(sample.outputStream,
-          "Error: --project-id arg required unless provided by the GOOGLE_PROJECT_ID "
-              + "or DEVSHELL_PROJECT_ID environment variables.");
+      usage("Error: --project-id arg required unless provided by the GOOGLE_CLOUD_PROJECT "
+          + "or DEVSHELL_PROJECT_ID environment variables.");
       return;
     }
 
@@ -190,7 +186,7 @@ public static void main(String[] args) throws IOException {
             cl.getOptionValue(FILTER_OPTION.getOpt()), false);
         break;
       default:
-        usage(sample.outputStream, null);
+        usage(null);
     }
   }
 
@@ -199,7 +195,7 @@ private static CommandLine parseCommandLine(String[] args, Options expectedOptio
     try {
       cl = PARSER.parse(expectedOptions, args);
     } catch (ParseException pe) {
-      usage(System.out, "Exception parsing command line arguments.");
+      usage("Exception parsing command line arguments.");
       throw new RuntimeException("Exception parsing command line arguments.", pe);
     }
     return cl;
@@ -210,7 +206,7 @@ private static AlertSample createAlertSample() throws IOException {
     try {
       sample = new AlertSample();
     } catch (Exception e) {
-      usage(System.out, "Exception creating alert sample.");
+      usage("Exception creating alert sample.");
       throw e;
     }
     return sample;
@@ -221,10 +217,19 @@ void listAlertPolicies(String projectId) {
     ListAlertPoliciesPagedResponse response = alertPolicyClient.listAlertPolicies(ProjectName.of(
         projectId));
 
+    System.out.println("Alert Policies:");
     for (AlertPolicy policy : response.iterateAll()) {
-      outputStream.println(policy.getDisplayName());
+      System.out.println(
+          String.format("\nPolicy %s\nalert-id: %s", policy.getDisplayName(), policy.getName()));
+      int channels = policy.getNotificationChannelsCount();
+      if (channels > 0) {
+        System.out.println("notification-channels:");
+        for (int i = 0; i < channels; i++) {
+          System.out.println("\t" + policy.getNotificationChannels(i));
+        }
+      }
       if (policy.hasDocumentation() && policy.getDocumentation().getContent() != null) {
-        outputStream.println(policy.getDocumentation().getContent());
+        System.out.println(policy.getDocumentation().getContent());
       }
     }
   }
@@ -235,7 +240,7 @@ void backupPolicies(String projectId, String filePath) throws IOException {
     List<AlertPolicy> alertPolicies = getAlertPolicies(projectId);
     List<NotificationChannel> notificationChannels = getNotificationChannels(projectId);
     writePoliciesBackupFile(projectId, filePath, alertPolicies, notificationChannels);
-    outputStream.println(String.format("Saved policies to %s", filePath));
+    System.out.println(String.format("Saved policies to %s", filePath));
   }
 
   private List<AlertPolicy> getAlertPolicies(String projectId) {
@@ -351,7 +356,7 @@ private void restoreRevisedPolicies(String projectId,
               policy.toBuilder().clearName().build());
         }
       }
-      outputStream.println(String.format("Restored %s", policy.getName()));
+      System.out.println(String.format("Restored %s", policy.getName()));
     }
   }
   // [END monitoring_alert_create_policy]
@@ -400,7 +405,7 @@ private Map<String, String> restoreNotificationChannels(String projectId,
   }
   // [END monitoring_alert_create_channel]
   // [END monitoring_alert_update_channel]
-  
+
   private JsonObject getPolicyJsonContents(String filePath, BufferedReader content, Gson gson) {
     try {
       return gson.fromJson(content, JsonObject.class);
@@ -421,7 +426,7 @@ void replaceChannels(String projectId, String alertPolicyId, String[] channelIds
     }
     AlertPolicy result = alertPolicyClient.updateAlertPolicy(
         FieldMask.newBuilder().addPaths("notification_channels").build(), policyBuilder.build());
-    outputStream.println(String.format("Updated %s", result.getName()));
+    System.out.println(String.format("Updated %s", result.getName()));
   }
   // [END monitoring_alert_replace_channels]
 
@@ -432,38 +437,37 @@ void enablePolicies(String projectId,
                       boolean enable) {
     ListAlertPoliciesPagedResponse response = alertPolicyClient
         .listAlertPolicies(ListAlertPoliciesRequest.newBuilder()
-            .setName(projectId)
+            .setName(ProjectName.of(projectId).toString())
             .setFilter(filter)
             .build());
 
     for (AlertPolicy policy : response.iterateAll()) {
       if (policy.getEnabled().getValue() == enable) {
-        outputStream.println(String.format("Policy %s is already %b.", policy.getName(), enable));
+        System.out.println(String.format(
+            "Policy %s is already %b.", policy.getName(), enable ? "enabled" : "disabled"));
         continue;
       }
       AlertPolicy updatedPolicy = AlertPolicy
           .newBuilder()
-          .setName(AlertPolicyName.of(projectId, policy.getName()).toString())
+          .setName(policy.getName())
           .setEnabled(BoolValue.newBuilder().setValue(enable))
           .build();
       AlertPolicy result = alertPolicyClient.updateAlertPolicy(
           FieldMask.newBuilder().addPaths("enabled").build(), updatedPolicy);
-      outputStream.println(String.format(
-          "%s %s", result.getName(), result.getEnabled().getValue() ? "Enabled" : "Disabled"));
+      System.out.println(String.format(
+          "%s %s",
+          result.getDisplayName(),
+          result.getEnabled().getValue() ? "enabled" : "disabled"));
     }
 
   }
   // [END monitoring_alert_enable_policies]
   // [END monitoring_alert_disable_policies]
 
-  private static void usage(PrintStream ps) {
-    usage(ps, null);
-  }
-
-  private static void usage(PrintStream ps, String message) {
-    Optional.ofNullable(message).ifPresent(ps::println);
-    ps.println("Usage:");
-    ps.printf(
+  private static void usage(String message) {
+    Optional.ofNullable(message).ifPresent(System.out::println);
+    System.out.println("Usage:");
+    System.out.printf(
         "\tjava %s \"<command>\" \"<args>\"\n"
             + "Args:\n"
             + "\t%s\n"

monitoring/v3/src/test/java/AlertIT.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Strings;
+import com.google.common.io.Files;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for monitoring "AlertSample" sample.
+ */
+@RunWith(JUnit4.class)
+@SuppressWarnings("checkstyle:abbreviationaswordinname")
+public class AlertIT {
+  private static String testPolicyName = "test-policy";
+  private static String policyFileName = "target/policyBackup.json";
+  private static Pattern policyNameRegex = Pattern.compile(
+      "alertPolicies/(?<alertid>.*)(?s).*(?!s)notificationChannels/(?<channel>[a-zA-Z0-9]*)$");
+  private ByteArrayOutputStream bout;
+  private PrintStream out;
+
+  @Before
+  public void setUp() {
+    bout = new ByteArrayOutputStream();
+    out = new PrintStream(bout);
+    System.setOut(out);
+  }
+
+  @After
+  public void tearDown() {
+    System.setOut(null);
+  }
+
+  @Test
+  public void testListPolicies() throws IOException {
+    AlertSample.main(new String[]{"list"});
+    assertTrue(bout.toString().contains(testPolicyName));
+  }
+
+  @Test
+  public void testBackupPolicies() throws IOException {
+    AlertSample.main(new String[]{"backup", "-j", policyFileName});
+    File backupFile = new File(policyFileName);
+    assertTrue(backupFile.exists());
+    String fileContents =
+        String.join("\n", Files.readLines(backupFile, StandardCharsets.UTF_8));
+    assertTrue(fileContents.contains("test-policy"));
+  }
+
+  // TODO(b/78293034): Complete restore backup test when parse/unparse issue is figured out.
+  @Test
+  @Ignore
+  public void testRestoreBackup() throws IOException {
+  }
+
+  @Test
+  public void testReplaceChannels() throws IOException {
+    // Get a test policy name for the project.
+    AlertSample.main(new String[]{"list"});
+    Matcher matcher = policyNameRegex.matcher(bout.toString());
+    assertTrue(matcher.find());
+    String alertId = matcher.group("alertid");
+    String channel = matcher.group("channel");
+    Assert.assertFalse(Strings.isNullOrEmpty(alertId));
+    AlertSample.main(new String[]{"replace-channels", "-a", alertId, "-c", channel});
+    Pattern resultPattern = Pattern.compile("(?s).*Updated .*/alertPolicies/" + alertId);
+    assertTrue(resultPattern.matcher(bout.toString()).find());
+  }
+
+  @Test
+  public void testDisableEnablePolicies() throws IOException {
+    AlertSample.main(new String[]{"disable", "-d", "display_name='test-policy'"});
+    assertTrue(bout.toString().contains("disabled"));
+    AlertSample.main(new String[]{"enable", "-d", "display_name='test-policy'"});
+    assertTrue(bout.toString().contains("enabled"));
+
+  }
+}