src/test/java/com/googlesource/gerrit/plugins/multisite/validation/InSyncChangeValidatorTest.java - plugins/multi-site - Git at Google

 // Copyright (C) 2019 The Android Open Source Project
 //
 // 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 com.googlesource.gerrit.plugins.multisite.validation;

 import static com.google.common.truth.Truth.assertThat;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.CoreMatchers.sameInstance;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.argThat;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;

 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.server.events.RefReceivedEvent;
 import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.gerrit.server.git.validators.ValidationMessage;
 import com.google.gerrit.server.validators.ValidationException;
 import com.googlesource.gerrit.plugins.multisite.validation.dfsrefdb.SharedRefDatabase;
 import java.io.IOException;
 import java.util.List;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.transport.ReceiveCommand;
 import org.eclipse.jgit.transport.ReceiveCommand.Type;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentMatcher;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;

 @RunWith(MockitoJUnitRunner.class)
 public class InSyncChangeValidatorTest {
   static final String PROJECT_NAME = "AProject";
   static final Project.NameKey PROJECT_NAMEKEY = new Project.NameKey(PROJECT_NAME);
   static final String REF_NAME = "refs/heads/master";
   static final String REF_PATCHSET_NAME = "refs/changes/45/1245/1";
   static final String REF_PATCHSET_META_NAME = "refs/changes/45/1245/1/meta";
   static final ObjectId REF_OBJID = ObjectId.fromString("f2ffe80abb77223f3f8921f3f068b0e32d40f798");
   static final ObjectId REF_OBJID_OLD =
       ObjectId.fromString("a9a7a6fd1e9ad39a13fef5e897dc6d932a3282e1");
   static final ReceiveCommand RECEIVE_COMMAND_CREATE_REF =
       new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_NAME, Type.CREATE);
   static final ReceiveCommand RECEIVE_COMMAND_UPDATE_REF =
       new ReceiveCommand(REF_OBJID_OLD, REF_OBJID, REF_NAME, Type.UPDATE);
   static final ReceiveCommand RECEIVE_COMMAND_DELETE_REF =
       new ReceiveCommand(REF_OBJID_OLD, ObjectId.zeroId(), REF_NAME, Type.DELETE);
   static final ReceiveCommand RECEIVE_COMMAND_CREATE_PATCHSET_REF =
       new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_PATCHSET_NAME, Type.CREATE);
   static final ReceiveCommand RECEIVE_COMMAND_CREATE_PATCHSET_META_REF =
       new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_PATCHSET_META_NAME, Type.CREATE);

   @Rule public ExpectedException expectedException = ExpectedException.none();

   @Mock SharedRefDatabase dfsRefDatabase;

   @Mock Repository repo;

   @Mock RefDatabase localRefDatabase;

   @Mock GitRepositoryManager repoManager;

   private InSyncChangeValidator validator;

   static class TestRef implements Ref {
     private final String name;
     private final ObjectId objectId;

     public TestRef(String name, ObjectId objectId) {
       super();
       this.name = name;
       this.objectId = objectId;
     }

     @Override
     public String getName() {
       return name;
     }

     @Override
     public boolean isSymbolic() {
       return false;
     }

     @Override
     public Ref getLeaf() {
       return null;
     }

     @Override
     public Ref getTarget() {
       return null;
     }

     @Override
     public ObjectId getObjectId() {
       return objectId;
     }

     @Override
     public ObjectId getPeeledObjectId() {
       return null;
     }

     @Override
     public boolean isPeeled() {
       return false;
     }

     @Override
     public Storage getStorage() {
       return Storage.LOOSE;
     }
   }

   static class RefMatcher implements ArgumentMatcher<Ref> {
     private final String name;
     private final ObjectId objectId;

     public RefMatcher(String name, ObjectId objectId) {
       super();
       this.name = name;
       this.objectId = objectId;
     }

     @Override
     public boolean matches(Ref that) {
       if (that == null) {
         return false;
       }

       return name.equals(that.getName()) && objectId.equals(that.getObjectId());
     }
   }

   public static Ref eqRef(String name, ObjectId objectId) {
     return argThat(new RefMatcher(name, objectId));
   }

   Ref testRef = new TestRef(REF_NAME, REF_OBJID);
   RefReceivedEvent testRefReceivedEvent =
       new RefReceivedEvent() {

         @Override
         public String getRefName() {
           return command.getRefName();
         }

         @Override
         public com.google.gerrit.reviewdb.client.Project.NameKey getProjectNameKey() {
           return PROJECT_NAMEKEY;
         }
       };

   @Before
   public void setUp() throws IOException {
     doReturn(testRef).when(dfsRefDatabase).newRef(REF_NAME, REF_OBJID);
     doReturn(repo).when(repoManager).openRepository(PROJECT_NAMEKEY);
     doReturn(localRefDatabase).when(repo).getRefDatabase();
     lenient()
         .doThrow(new NullPointerException("oldRef is null"))
         .when(dfsRefDatabase)
         .compareAndPut(any(), eq(null), any());
     lenient()
         .doThrow(new NullPointerException("newRef is null"))
         .when(dfsRefDatabase)
         .compareAndPut(any(), any(), eq(null));
     lenient()
         .doThrow(new NullPointerException("project name is null"))
         .when(dfsRefDatabase)
         .compareAndPut(eq(null), any(), any());

     validator = new InSyncChangeValidator(dfsRefDatabase, repoManager);
     repoManager.createRepository(PROJECT_NAMEKEY);
   }

   @Test
   public void shouldNotVerifyStatusOfImmutablePatchSetRefs() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_PATCHSET_REF;
     final List<ValidationMessage> validationMessages =
         validator.onRefOperation(testRefReceivedEvent);

     assertThat(validationMessages).isEmpty();

     verifyZeroInteractions(dfsRefDatabase);
   }

   @Test
   public void shouldVerifyStatusOfPatchSetMetaRefs() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_PATCHSET_META_REF;

     Ref testRefMeta = new TestRef(REF_PATCHSET_META_NAME, REF_OBJID);
     doReturn(testRefMeta).when(dfsRefDatabase).newRef(REF_PATCHSET_META_NAME, REF_OBJID);

     validator.onRefOperation(testRefReceivedEvent);

     verify(dfsRefDatabase)
         .compareAndCreate(eq(PROJECT_NAME), eqRef(REF_PATCHSET_META_NAME, REF_OBJID));
   }

   @Test
   public void shouldInsertNewRefInDfsDatabaseWhenHandlingRefCreationEvents() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_REF;

     final List<ValidationMessage> validationMessages =
         validator.onRefOperation(testRefReceivedEvent);

     assertThat(validationMessages).isEmpty();
     verify(dfsRefDatabase).compareAndCreate(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID));
   }

   @Test
   public void shouldFailRefCreationIfInsertANewRefInDfsDatabaseFails() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_REF;

     IllegalArgumentException alreadyInDb = new IllegalArgumentException("obj is already in db");

     doThrow(alreadyInDb)
         .when(dfsRefDatabase)
         .compareAndCreate(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID));

     expectedException.expect(ValidationException.class);
     expectedException.expectCause(sameInstance(alreadyInDb));

     validator.onRefOperation(testRefReceivedEvent);
   }

   @Test
   public void shouldUpdateRefInDfsDatabaseWhenHandlingRefUpdateEvents() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
     doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
     doReturn(true)
         .when(dfsRefDatabase)
         .compareAndPut(
             eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));

     final List<ValidationMessage> validationMessages =
         validator.onRefOperation(testRefReceivedEvent);

     assertThat(validationMessages).isEmpty();
     verify(dfsRefDatabase)
         .compareAndPut(
             eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));
   }

   @Test
   public void shouldFailRefUpdateIfRefUpdateInDfsRefDatabaseReturnsFalse() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
     doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
     doReturn(false)
         .when(dfsRefDatabase)
         .compareAndPut(
             eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));
     expectedException.expect(ValidationException.class);
     expectedException.expectCause(nullValue(Exception.class));

     validator.onRefOperation(testRefReceivedEvent);
   }

   @Test
   public void shouldFailRefUpdateIfRefIsNotInDfsRefDatabase() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
     doReturn(null).when(localRefDatabase).getRef(REF_NAME);

     expectedException.expect(ValidationException.class);
     expectedException.expectCause(nullValue(Exception.class));

     validator.onRefOperation(testRefReceivedEvent);
   }

   @Test
   public void shouldDeleteRefInDfsDatabaseWhenHandlingRefDeleteEvents() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
     doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
     doReturn(true)
         .when(dfsRefDatabase)
         .compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));

     final List<ValidationMessage> validationMessages =
         validator.onRefOperation(testRefReceivedEvent);

     assertThat(validationMessages).isEmpty();

     verify(dfsRefDatabase).compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));
   }

   @Test
   public void shouldFailRefDeletionIfRefDeletionInDfsRefDatabaseReturnsFalse() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
     doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
     doReturn(false)
         .when(dfsRefDatabase)
         .compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));

     expectedException.expect(ValidationException.class);
     expectedException.expectCause(nullValue(Exception.class));

     validator.onRefOperation(testRefReceivedEvent);
   }

   @Test
   public void shouldFailRefDeletionIfRefIsNotInDfsDatabase() throws Exception {
     testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
     doReturn(null).when(localRefDatabase).getRef(REF_NAME);

     expectedException.expect(ValidationException.class);
     expectedException.expectCause(nullValue(Exception.class));

     validator.onRefOperation(testRefReceivedEvent);
   }
 }
	// Copyright (C) 2019 The Android Open Source Project
	//
	// 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 com.googlesource.gerrit.plugins.multisite.validation;

	import static com.google.common.truth.Truth.assertThat;
	import static org.hamcrest.CoreMatchers.nullValue;
	import static org.hamcrest.CoreMatchers.sameInstance;
	import static org.mockito.Mockito.any;
	import static org.mockito.Mockito.argThat;
	import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.doThrow;
	import static org.mockito.Mockito.eq;
	import static org.mockito.Mockito.lenient;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.verifyZeroInteractions;

	import com.google.gerrit.reviewdb.client.Project;
	import com.google.gerrit.server.events.RefReceivedEvent;
	import com.google.gerrit.server.git.GitRepositoryManager;
	import com.google.gerrit.server.git.validators.ValidationMessage;
	import com.google.gerrit.server.validators.ValidationException;
	import com.googlesource.gerrit.plugins.multisite.validation.dfsrefdb.SharedRefDatabase;
	import java.io.IOException;
	import java.util.List;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.RefDatabase;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.transport.ReceiveCommand;
	import org.eclipse.jgit.transport.ReceiveCommand.Type;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.rules.ExpectedException;
	import org.junit.runner.RunWith;
	import org.mockito.ArgumentMatcher;
	import org.mockito.Mock;
	import org.mockito.junit.MockitoJUnitRunner;

	@RunWith(MockitoJUnitRunner.class)
	public class InSyncChangeValidatorTest {
	static final String PROJECT_NAME = "AProject";
	static final Project.NameKey PROJECT_NAMEKEY = new Project.NameKey(PROJECT_NAME);
	static final String REF_NAME = "refs/heads/master";
	static final String REF_PATCHSET_NAME = "refs/changes/45/1245/1";
	static final String REF_PATCHSET_META_NAME = "refs/changes/45/1245/1/meta";
	static final ObjectId REF_OBJID = ObjectId.fromString("f2ffe80abb77223f3f8921f3f068b0e32d40f798");
	static final ObjectId REF_OBJID_OLD =
	ObjectId.fromString("a9a7a6fd1e9ad39a13fef5e897dc6d932a3282e1");
	static final ReceiveCommand RECEIVE_COMMAND_CREATE_REF =
	new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_NAME, Type.CREATE);
	static final ReceiveCommand RECEIVE_COMMAND_UPDATE_REF =
	new ReceiveCommand(REF_OBJID_OLD, REF_OBJID, REF_NAME, Type.UPDATE);
	static final ReceiveCommand RECEIVE_COMMAND_DELETE_REF =
	new ReceiveCommand(REF_OBJID_OLD, ObjectId.zeroId(), REF_NAME, Type.DELETE);
	static final ReceiveCommand RECEIVE_COMMAND_CREATE_PATCHSET_REF =
	new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_PATCHSET_NAME, Type.CREATE);
	static final ReceiveCommand RECEIVE_COMMAND_CREATE_PATCHSET_META_REF =
	new ReceiveCommand(ObjectId.zeroId(), REF_OBJID, REF_PATCHSET_META_NAME, Type.CREATE);

	@Rule public ExpectedException expectedException = ExpectedException.none();

	@Mock SharedRefDatabase dfsRefDatabase;

	@Mock Repository repo;

	@Mock RefDatabase localRefDatabase;

	@Mock GitRepositoryManager repoManager;

	private InSyncChangeValidator validator;

	static class TestRef implements Ref {
	private final String name;
	private final ObjectId objectId;

	public TestRef(String name, ObjectId objectId) {
	super();
	this.name = name;
	this.objectId = objectId;
	}

	@Override
	public String getName() {
	return name;
	}

	@Override
	public boolean isSymbolic() {
	return false;
	}

	@Override
	public Ref getLeaf() {
	return null;
	}

	@Override
	public Ref getTarget() {
	return null;
	}

	@Override
	public ObjectId getObjectId() {
	return objectId;
	}

	@Override
	public ObjectId getPeeledObjectId() {
	return null;
	}

	@Override
	public boolean isPeeled() {
	return false;
	}

	@Override
	public Storage getStorage() {
	return Storage.LOOSE;
	}
	}

	static class RefMatcher implements ArgumentMatcher<Ref> {
	private final String name;
	private final ObjectId objectId;

	public RefMatcher(String name, ObjectId objectId) {
	super();
	this.name = name;
	this.objectId = objectId;
	}

	@Override
	public boolean matches(Ref that) {
	if (that == null) {
	return false;
	}

	return name.equals(that.getName()) && objectId.equals(that.getObjectId());
	}
	}

	public static Ref eqRef(String name, ObjectId objectId) {
	return argThat(new RefMatcher(name, objectId));
	}

	Ref testRef = new TestRef(REF_NAME, REF_OBJID);
	RefReceivedEvent testRefReceivedEvent =
	new RefReceivedEvent() {

	@Override
	public String getRefName() {
	return command.getRefName();
	}

	@Override
	public com.google.gerrit.reviewdb.client.Project.NameKey getProjectNameKey() {
	return PROJECT_NAMEKEY;
	}
	};

	@Before
	public void setUp() throws IOException {
	doReturn(testRef).when(dfsRefDatabase).newRef(REF_NAME, REF_OBJID);
	doReturn(repo).when(repoManager).openRepository(PROJECT_NAMEKEY);
	doReturn(localRefDatabase).when(repo).getRefDatabase();
	lenient()
	.doThrow(new NullPointerException("oldRef is null"))
	.when(dfsRefDatabase)
	.compareAndPut(any(), eq(null), any());
	lenient()
	.doThrow(new NullPointerException("newRef is null"))
	.when(dfsRefDatabase)
	.compareAndPut(any(), any(), eq(null));
	lenient()
	.doThrow(new NullPointerException("project name is null"))
	.when(dfsRefDatabase)
	.compareAndPut(eq(null), any(), any());

	validator = new InSyncChangeValidator(dfsRefDatabase, repoManager);
	repoManager.createRepository(PROJECT_NAMEKEY);
	}

	@Test
	public void shouldNotVerifyStatusOfImmutablePatchSetRefs() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_PATCHSET_REF;
	final List<ValidationMessage> validationMessages =
	validator.onRefOperation(testRefReceivedEvent);

	assertThat(validationMessages).isEmpty();

	verifyZeroInteractions(dfsRefDatabase);
	}

	@Test
	public void shouldVerifyStatusOfPatchSetMetaRefs() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_PATCHSET_META_REF;

	Ref testRefMeta = new TestRef(REF_PATCHSET_META_NAME, REF_OBJID);
	doReturn(testRefMeta).when(dfsRefDatabase).newRef(REF_PATCHSET_META_NAME, REF_OBJID);

	validator.onRefOperation(testRefReceivedEvent);

	verify(dfsRefDatabase)
	.compareAndCreate(eq(PROJECT_NAME), eqRef(REF_PATCHSET_META_NAME, REF_OBJID));
	}

	@Test
	public void shouldInsertNewRefInDfsDatabaseWhenHandlingRefCreationEvents() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_REF;

	final List<ValidationMessage> validationMessages =
	validator.onRefOperation(testRefReceivedEvent);

	assertThat(validationMessages).isEmpty();
	verify(dfsRefDatabase).compareAndCreate(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID));
	}

	@Test
	public void shouldFailRefCreationIfInsertANewRefInDfsDatabaseFails() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_CREATE_REF;

	IllegalArgumentException alreadyInDb = new IllegalArgumentException("obj is already in db");

	doThrow(alreadyInDb)
	.when(dfsRefDatabase)
	.compareAndCreate(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID));

	expectedException.expect(ValidationException.class);
	expectedException.expectCause(sameInstance(alreadyInDb));

	validator.onRefOperation(testRefReceivedEvent);
	}

	@Test
	public void shouldUpdateRefInDfsDatabaseWhenHandlingRefUpdateEvents() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
	doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
	doReturn(true)
	.when(dfsRefDatabase)
	.compareAndPut(
	eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));

	final List<ValidationMessage> validationMessages =
	validator.onRefOperation(testRefReceivedEvent);

	assertThat(validationMessages).isEmpty();
	verify(dfsRefDatabase)
	.compareAndPut(
	eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));
	}

	@Test
	public void shouldFailRefUpdateIfRefUpdateInDfsRefDatabaseReturnsFalse() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
	doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
	doReturn(false)
	.when(dfsRefDatabase)
	.compareAndPut(
	eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD), eqRef(REF_NAME, REF_OBJID));
	expectedException.expect(ValidationException.class);
	expectedException.expectCause(nullValue(Exception.class));

	validator.onRefOperation(testRefReceivedEvent);
	}

	@Test
	public void shouldFailRefUpdateIfRefIsNotInDfsRefDatabase() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_UPDATE_REF;
	doReturn(null).when(localRefDatabase).getRef(REF_NAME);

	expectedException.expect(ValidationException.class);
	expectedException.expectCause(nullValue(Exception.class));

	validator.onRefOperation(testRefReceivedEvent);
	}

	@Test
	public void shouldDeleteRefInDfsDatabaseWhenHandlingRefDeleteEvents() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
	doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
	doReturn(true)
	.when(dfsRefDatabase)
	.compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));

	final List<ValidationMessage> validationMessages =
	validator.onRefOperation(testRefReceivedEvent);

	assertThat(validationMessages).isEmpty();

	verify(dfsRefDatabase).compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));
	}

	@Test
	public void shouldFailRefDeletionIfRefDeletionInDfsRefDatabaseReturnsFalse() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
	doReturn(new TestRef(REF_NAME, REF_OBJID_OLD)).when(localRefDatabase).getRef(REF_NAME);
	doReturn(false)
	.when(dfsRefDatabase)
	.compareAndRemove(eq(PROJECT_NAME), eqRef(REF_NAME, REF_OBJID_OLD));

	expectedException.expect(ValidationException.class);
	expectedException.expectCause(nullValue(Exception.class));

	validator.onRefOperation(testRefReceivedEvent);
	}

	@Test
	public void shouldFailRefDeletionIfRefIsNotInDfsDatabase() throws Exception {
	testRefReceivedEvent.command = RECEIVE_COMMAND_DELETE_REF;
	doReturn(null).when(localRefDatabase).getRef(REF_NAME);

	expectedException.expect(ValidationException.class);
	expectedException.expectCause(nullValue(Exception.class));

	validator.onRefOperation(testRefReceivedEvent);
	}
	}