Line data    Source code

       1             : // Copyright (C) 2018 The Android Open Source Project
       2             : //
       3             : // Licensed under the Apache License, Version 2.0 (the "License");
       4             : // you may not use this file except in compliance with the License.
       5             : // You may obtain a copy of the License at
       6             : //
       7             : // http://www.apache.org/licenses/LICENSE-2.0
       8             : //
       9             : // Unless required by applicable law or agreed to in writing, software
      10             : // distributed under the License is distributed on an "AS IS" BASIS,
      11             : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             : // See the License for the specific language governing permissions and
      13             : // limitations under the License.
      14             : 
      15             : package com.google.gerrit.acceptance.testsuite.group;
      16             : 
      17             : import com.google.auto.value.AutoValue;
      18             : import com.google.common.collect.ImmutableSet;
      19             : import com.google.common.collect.Sets;
      20             : import com.google.gerrit.acceptance.testsuite.ThrowingConsumer;
      21             : import com.google.gerrit.entities.Account;
      22             : import com.google.gerrit.entities.AccountGroup;
      23             : import java.util.Optional;
      24             : import java.util.Set;
      25             : import java.util.function.Function;
      26             : 
      27             : @AutoValue
      28           9 : public abstract class TestGroupUpdate {
      29             : 
      30             :   public abstract Optional<String> name();
      31             : 
      32             :   public abstract Optional<String> description();
      33             : 
      34             :   public abstract Optional<AccountGroup.UUID> ownerGroupUuid();
      35             : 
      36             :   public abstract Optional<Boolean> visibleToAll();
      37             : 
      38             :   public abstract Function<ImmutableSet<Account.Id>, Set<Account.Id>> memberModification();
      39             : 
      40             :   public abstract Function<ImmutableSet<AccountGroup.UUID>, Set<AccountGroup.UUID>>
      41             :       subgroupModification();
      42             : 
      43             :   abstract ThrowingConsumer<TestGroupUpdate> groupUpdater();
      44             : 
      45             :   public static Builder builder(ThrowingConsumer<TestGroupUpdate> groupUpdater) {
      46          10 :     return new AutoValue_TestGroupUpdate.Builder()
      47          10 :         .groupUpdater(groupUpdater)
      48          10 :         .memberModification(in -> in)
      49          10 :         .subgroupModification(in -> in);
      50             :   }
      51             : 
      52             :   @AutoValue.Builder
      53          10 :   public abstract static class Builder {
      54             : 
      55             :     public abstract Builder name(String name);
      56             : 
      57             :     public abstract Builder description(String description);
      58             : 
      59             :     public Builder clearDescription() {
      60           1 :       return description("");
      61             :     }
      62             : 
      63             :     public abstract Builder ownerGroupUuid(AccountGroup.UUID ownerGroupUUID);
      64             : 
      65             :     public abstract Builder visibleToAll(boolean visibleToAll);
      66             : 
      67             :     abstract Builder memberModification(
      68             :         Function<ImmutableSet<Account.Id>, Set<Account.Id>> memberModification);
      69             : 
      70             :     abstract Function<ImmutableSet<Account.Id>, Set<Account.Id>> memberModification();
      71             : 
      72             :     public Builder clearMembers() {
      73           1 :       return memberModification(originalMembers -> ImmutableSet.of());
      74             :     }
      75             : 
      76             :     public Builder addMember(Account.Id member) {
      77           7 :       Function<ImmutableSet<Account.Id>, Set<Account.Id>> previousModification =
      78           7 :           memberModification();
      79           7 :       memberModification(
      80             :           originalMembers ->
      81           7 :               Sets.union(previousModification.apply(originalMembers), ImmutableSet.of(member)));
      82           7 :       return this;
      83             :     }
      84             : 
      85             :     public Builder removeMember(Account.Id member) {
      86           1 :       Function<ImmutableSet<Account.Id>, Set<Account.Id>> previousModification =
      87           1 :           memberModification();
      88           1 :       memberModification(
      89             :           originalMembers ->
      90           1 :               Sets.difference(
      91           1 :                   previousModification.apply(originalMembers), ImmutableSet.of(member)));
      92           1 :       return this;
      93             :     }
      94             : 
      95             :     abstract Builder subgroupModification(
      96             :         Function<ImmutableSet<AccountGroup.UUID>, Set<AccountGroup.UUID>> subgroupModification);
      97             : 
      98             :     abstract Function<ImmutableSet<AccountGroup.UUID>, Set<AccountGroup.UUID>>
      99             :         subgroupModification();
     100             : 
     101             :     public Builder clearSubgroups() {
     102           1 :       return subgroupModification(originalMembers -> ImmutableSet.of());
     103             :     }
     104             : 
     105             :     public Builder addSubgroup(AccountGroup.UUID subgroup) {
     106           3 :       Function<ImmutableSet<AccountGroup.UUID>, Set<AccountGroup.UUID>> previousModification =
     107           3 :           subgroupModification();
     108           3 :       subgroupModification(
     109             :           originalSubgroups ->
     110           2 :               Sets.union(previousModification.apply(originalSubgroups), ImmutableSet.of(subgroup)));
     111           3 :       return this;
     112             :     }
     113             : 
     114             :     public Builder removeSubgroup(AccountGroup.UUID subgroup) {
     115           1 :       Function<ImmutableSet<AccountGroup.UUID>, Set<AccountGroup.UUID>> previousModification =
     116           1 :           subgroupModification();
     117           1 :       subgroupModification(
     118             :           originalSubgroups ->
     119           1 :               Sets.difference(
     120           1 :                   previousModification.apply(originalSubgroups), ImmutableSet.of(subgroup)));
     121           1 :       return this;
     122             :     }
     123             : 
     124             :     abstract Builder groupUpdater(ThrowingConsumer<TestGroupUpdate> groupUpdater);
     125             : 
     126             :     abstract TestGroupUpdate autoBuild();
     127             : 
     128             :     /** Executes the group update as specified. */
     129             :     public void update() {
     130           9 :       TestGroupUpdate groupUpdater = autoBuild();
     131           9 :       groupUpdater.groupUpdater().acceptAndThrowSilently(groupUpdater);
     132           9 :     }
     133             :   }
     134             : }