mirror of
https://github.com/google/nomulus.git
synced 2025-05-01 04:27:51 +02:00
8a4407a9a1
Part of the attempt to remove or suppress warnings for deprecated API use, which will make the Gradle project usable with Intellij. Currently in the Intellij/Gradle setup, deprecation warnings cause Intellij build process to fail. Passing -Werror:none flags to javac\ does not have any effect. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=246135737
251 lines
10 KiB
Java
251 lines
10 KiB
Java
// Copyright 2017 The Nomulus Authors. All Rights Reserved.
|
|
//
|
|
// 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.
|
|
|
|
package google.registry.batch;
|
|
|
|
import static com.google.appengine.api.taskqueue.QueueFactory.getQueue;
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
import static com.google.common.truth.Truth8.assertThat;
|
|
import static google.registry.batch.AsyncTaskEnqueuer.QUEUE_ASYNC_ACTIONS;
|
|
import static google.registry.batch.AsyncTaskEnqueuer.QUEUE_ASYNC_DELETE;
|
|
import static google.registry.batch.AsyncTaskEnqueuer.QUEUE_ASYNC_HOST_RENAME;
|
|
import static google.registry.batch.AsyncTaskMetrics.OperationType.DNS_REFRESH;
|
|
import static google.registry.model.ofy.ObjectifyService.ofy;
|
|
import static google.registry.testing.DatastoreHelper.createTld;
|
|
import static google.registry.testing.DatastoreHelper.newDomainBase;
|
|
import static google.registry.testing.DatastoreHelper.newHostResource;
|
|
import static google.registry.testing.DatastoreHelper.persistActiveHost;
|
|
import static google.registry.testing.DatastoreHelper.persistDeletedHost;
|
|
import static google.registry.testing.DatastoreHelper.persistResource;
|
|
import static google.registry.testing.TaskQueueHelper.assertDnsTasksEnqueued;
|
|
import static google.registry.testing.TaskQueueHelper.assertNoDnsTasksEnqueued;
|
|
import static google.registry.testing.TaskQueueHelper.assertNoTasksEnqueued;
|
|
import static google.registry.testing.TaskQueueHelper.assertTasksEnqueued;
|
|
import static google.registry.util.DateTimeUtils.START_OF_TIME;
|
|
import static org.joda.time.Duration.millis;
|
|
import static org.joda.time.Duration.standardDays;
|
|
import static org.joda.time.Duration.standardHours;
|
|
import static org.joda.time.Duration.standardSeconds;
|
|
import static org.mockito.ArgumentMatchers.anyString;
|
|
import static org.mockito.Mockito.mock;
|
|
import static org.mockito.Mockito.times;
|
|
import static org.mockito.Mockito.verify;
|
|
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
|
import static org.mockito.Mockito.when;
|
|
|
|
import com.googlecode.objectify.Key;
|
|
import google.registry.batch.AsyncTaskMetrics.OperationResult;
|
|
import google.registry.batch.RefreshDnsOnHostRenameAction.RefreshDnsOnHostRenameReducer;
|
|
import google.registry.model.host.HostResource;
|
|
import google.registry.model.server.Lock;
|
|
import google.registry.testing.FakeClock;
|
|
import google.registry.testing.FakeResponse;
|
|
import google.registry.testing.FakeSleeper;
|
|
import google.registry.testing.InjectRule;
|
|
import google.registry.testing.TaskQueueHelper.TaskMatcher;
|
|
import google.registry.testing.mapreduce.MapreduceTestCase;
|
|
import google.registry.util.AppEngineServiceUtils;
|
|
import google.registry.util.RequestStatusChecker;
|
|
import google.registry.util.Retrier;
|
|
import google.registry.util.Sleeper;
|
|
import google.registry.util.SystemSleeper;
|
|
import java.util.Optional;
|
|
import org.joda.time.DateTime;
|
|
import org.joda.time.Duration;
|
|
import org.junit.Before;
|
|
import org.junit.Rule;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.junit.runners.JUnit4;
|
|
import org.mockito.Mock;
|
|
|
|
/** Unit tests for {@link RefreshDnsOnHostRenameAction}. */
|
|
@RunWith(JUnit4.class)
|
|
public class RefreshDnsOnHostRenameActionTest
|
|
extends MapreduceTestCase<RefreshDnsOnHostRenameAction> {
|
|
|
|
@Rule public final InjectRule inject = new InjectRule();
|
|
|
|
private AsyncTaskEnqueuer enqueuer;
|
|
private final FakeClock clock = new FakeClock(DateTime.parse("2015-01-15T11:22:33Z"));
|
|
private final FakeResponse fakeResponse = new FakeResponse();
|
|
@Mock private RequestStatusChecker requestStatusChecker;
|
|
|
|
@Before
|
|
public void setup() {
|
|
createTld("tld");
|
|
enqueuer =
|
|
new AsyncTaskEnqueuer(
|
|
getQueue(QUEUE_ASYNC_ACTIONS),
|
|
getQueue(QUEUE_ASYNC_DELETE),
|
|
getQueue(QUEUE_ASYNC_HOST_RENAME),
|
|
Duration.ZERO,
|
|
mock(AppEngineServiceUtils.class),
|
|
new Retrier(new FakeSleeper(clock), 1));
|
|
AsyncTaskMetrics asyncTaskMetricsMock = mock(AsyncTaskMetrics.class);
|
|
action = new RefreshDnsOnHostRenameAction();
|
|
action.asyncTaskMetrics = asyncTaskMetricsMock;
|
|
inject.setStaticField(
|
|
RefreshDnsOnHostRenameReducer.class, "asyncTaskMetrics", asyncTaskMetricsMock);
|
|
action.clock = clock;
|
|
action.mrRunner = makeDefaultRunner();
|
|
action.pullQueue = getQueue(QUEUE_ASYNC_HOST_RENAME);
|
|
action.requestStatusChecker = requestStatusChecker;
|
|
action.response = fakeResponse;
|
|
action.retrier = new Retrier(new FakeSleeper(clock), 1);
|
|
when(requestStatusChecker.getLogId()).thenReturn("requestId");
|
|
when(requestStatusChecker.isRunning(anyString()))
|
|
.thenThrow(new AssertionError("Should not be called"));
|
|
}
|
|
|
|
private void runMapreduce() throws Exception {
|
|
clock.advanceOneMilli();
|
|
// Use hard sleeps to ensure that the tasks are enqueued properly and will be leased.
|
|
Sleeper sleeper = new SystemSleeper();
|
|
sleeper.sleep(millis(50));
|
|
action.run();
|
|
sleeper.sleep(millis(50));
|
|
executeTasksUntilEmpty("mapreduce", clock);
|
|
sleeper.sleep(millis(50));
|
|
clock.advanceBy(standardSeconds(5));
|
|
ofy().clearSessionCache();
|
|
}
|
|
|
|
/** Kicks off, but does not run, the mapreduce tasks. Useful for testing validation/setup. */
|
|
private void enqueueMapreduceOnly() {
|
|
clock.advanceOneMilli();
|
|
action.run();
|
|
clock.advanceBy(standardSeconds(5));
|
|
ofy().clearSessionCache();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_dnsUpdateEnqueued() throws Exception {
|
|
HostResource host = persistActiveHost("ns1.example.tld");
|
|
persistResource(newDomainBase("example.tld", host));
|
|
persistResource(newDomainBase("otherexample.tld", host));
|
|
persistResource(newDomainBase("untouched.tld", persistActiveHost("ns2.example.tld")));
|
|
DateTime timeEnqueued = clock.nowUtc();
|
|
enqueuer.enqueueAsyncDnsRefresh(host, timeEnqueued);
|
|
runMapreduce();
|
|
assertDnsTasksEnqueued("example.tld", "otherexample.tld");
|
|
assertNoTasksEnqueued(QUEUE_ASYNC_HOST_RENAME);
|
|
verify(action.asyncTaskMetrics).recordDnsRefreshBatchSize(1L);
|
|
verify(action.asyncTaskMetrics)
|
|
.recordAsyncFlowResult(DNS_REFRESH, OperationResult.SUCCESS, timeEnqueued);
|
|
verifyNoMoreInteractions(action.asyncTaskMetrics);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_multipleHostsProcessedInBatch() throws Exception {
|
|
HostResource host1 = persistActiveHost("ns1.example.tld");
|
|
HostResource host2 = persistActiveHost("ns2.example.tld");
|
|
HostResource host3 = persistActiveHost("ns3.example.tld");
|
|
persistResource(newDomainBase("example1.tld", host1));
|
|
persistResource(newDomainBase("example2.tld", host2));
|
|
persistResource(newDomainBase("example3.tld", host3));
|
|
DateTime timeEnqueued = clock.nowUtc();
|
|
DateTime laterTimeEnqueued = timeEnqueued.plus(standardSeconds(10));
|
|
enqueuer.enqueueAsyncDnsRefresh(host1, timeEnqueued);
|
|
enqueuer.enqueueAsyncDnsRefresh(host2, timeEnqueued);
|
|
enqueuer.enqueueAsyncDnsRefresh(host3, laterTimeEnqueued);
|
|
runMapreduce();
|
|
assertDnsTasksEnqueued("example1.tld", "example2.tld", "example3.tld");
|
|
assertNoTasksEnqueued(QUEUE_ASYNC_HOST_RENAME);
|
|
verify(action.asyncTaskMetrics).recordDnsRefreshBatchSize(3L);
|
|
verify(action.asyncTaskMetrics, times(2))
|
|
.recordAsyncFlowResult(DNS_REFRESH, OperationResult.SUCCESS, timeEnqueued);
|
|
verify(action.asyncTaskMetrics)
|
|
.recordAsyncFlowResult(DNS_REFRESH, OperationResult.SUCCESS, laterTimeEnqueued);
|
|
verifyNoMoreInteractions(action.asyncTaskMetrics);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_deletedHost_doesntTriggerDnsRefresh() throws Exception {
|
|
HostResource host = persistDeletedHost("ns11.fakesss.tld", clock.nowUtc().minusDays(4));
|
|
persistResource(newDomainBase("example1.tld", host));
|
|
DateTime timeEnqueued = clock.nowUtc();
|
|
enqueuer.enqueueAsyncDnsRefresh(host, timeEnqueued);
|
|
runMapreduce();
|
|
assertNoDnsTasksEnqueued();
|
|
assertNoTasksEnqueued(QUEUE_ASYNC_HOST_RENAME);
|
|
verify(action.asyncTaskMetrics).recordDnsRefreshBatchSize(1L);
|
|
verify(action.asyncTaskMetrics)
|
|
.recordAsyncFlowResult(DNS_REFRESH, OperationResult.STALE, timeEnqueued);
|
|
verifyNoMoreInteractions(action.asyncTaskMetrics);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_noDnsTasksForDeletedDomain() throws Exception {
|
|
HostResource renamedHost = persistActiveHost("ns1.example.tld");
|
|
persistResource(
|
|
newDomainBase("example.tld", renamedHost)
|
|
.asBuilder()
|
|
.setDeletionTime(START_OF_TIME)
|
|
.build());
|
|
enqueuer.enqueueAsyncDnsRefresh(renamedHost, clock.nowUtc());
|
|
runMapreduce();
|
|
assertNoDnsTasksEnqueued();
|
|
assertNoTasksEnqueued(QUEUE_ASYNC_HOST_RENAME);
|
|
}
|
|
|
|
@Test
|
|
public void testRun_hostDoesntExist_delaysTask() throws Exception {
|
|
HostResource host = newHostResource("ns1.example.tld");
|
|
enqueuer.enqueueAsyncDnsRefresh(host, clock.nowUtc());
|
|
enqueueMapreduceOnly();
|
|
assertNoDnsTasksEnqueued();
|
|
assertTasksEnqueued(
|
|
QUEUE_ASYNC_HOST_RENAME,
|
|
new TaskMatcher()
|
|
.etaDelta(standardHours(23), standardHours(25))
|
|
.param("hostKey", Key.create(host).getString()));
|
|
assertThat(acquireLock()).isPresent();
|
|
}
|
|
|
|
@Test
|
|
public void test_cannotAcquireLock() {
|
|
// Make lock acquisition fail.
|
|
acquireLock();
|
|
enqueueMapreduceOnly();
|
|
assertThat(fakeResponse.getPayload()).isEqualTo("Can't acquire lock; aborting.");
|
|
assertNoDnsTasksEnqueued();
|
|
}
|
|
|
|
@Test
|
|
public void test_mapreduceHasWorkToDo_lockIsAcquired() {
|
|
HostResource host = persistActiveHost("ns1.example.tld");
|
|
enqueuer.enqueueAsyncDnsRefresh(host, clock.nowUtc());
|
|
enqueueMapreduceOnly();
|
|
assertThat(acquireLock()).isEmpty();
|
|
}
|
|
|
|
@Test
|
|
public void test_noTasksToLease_releasesLockImmediately() throws Exception {
|
|
enqueueMapreduceOnly();
|
|
assertNoDnsTasksEnqueued();
|
|
assertNoTasksEnqueued(QUEUE_ASYNC_HOST_RENAME);
|
|
// If the Lock was correctly released, then we can acquire it now.
|
|
assertThat(acquireLock()).isPresent();
|
|
}
|
|
|
|
private Optional<Lock> acquireLock() {
|
|
return Lock.acquire(
|
|
RefreshDnsOnHostRenameAction.class.getSimpleName(),
|
|
null,
|
|
standardDays(30),
|
|
requestStatusChecker,
|
|
false);
|
|
}
|
|
}
|