diff --git a/doc/release-notes/11918-template-apis.md b/doc/release-notes/11918-template-apis.md
new file mode 100644
index 00000000000..b970fd02c70
--- /dev/null
+++ b/doc/release-notes/11918-template-apis.md
@@ -0,0 +1,17 @@
+## New Endpoint: GET `/dataverses/{id}/template`
+
+A new endpoint has been implemented to manage templates belonging to a given dataverse collection.
+
+### Functionality
+- Returns the template of the given {id} in json format.
+- You must have add dataset permission in the collection in order to use this endpoint.
+
+## New Endpoint: DELETE `/dataverses/{id}/template`
+
+A new endpoint has been implemented to manage templates belonging to a given dataverse collection.
+
+### Functionality
+- Deletes the template of the given {id}.
+- You must have Edit Dataverse permission in order to use this endpoint.
+
+
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
index 6c1720e2b5b..8e5b5ac4e35 100644
--- a/doc/sphinx-guides/source/api/native-api.rst
+++ b/doc/sphinx-guides/source/api/native-api.rst
@@ -1576,6 +1576,48 @@ The fully expanded example above (without environment variables) looks like this
 
   curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X GET "https://demo.dataverse.org/api/dataverses/1/templates"
 
+List Single Template by its Identifier
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Gets the json representation of a template by its ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X GET "$SERVER_URL/api/dataverses/{ID}/template"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X GET "https://demo.dataverse.org/api/dataverses/1/template"
+
+You must have Create Dataset permission within the given dataverse collection to invoke this api.
+
+Delete a Template by its Identifier
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Deletes a template by its ``id``:
+
+.. code-block:: bash
+
+  export API_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+  export SERVER_URL=https://demo.dataverse.org
+  export ID=1
+
+  curl -H "X-Dataverse-key:$API_TOKEN" -X DELETE "$SERVER_URL/api/dataverses/{ID}/template"
+
+The fully expanded example above (without environment variables) looks like this:
+
+.. code-block:: bash
+
+  curl -H "X-Dataverse-key:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" -X DELETE "https://demo.dataverse.org/api/dataverses/1/template"
+
+You must have Edit Dataverse permission within the given dataverse collection to invoke this api.
+
 Create a Template for a Collection
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
index ed078d85518..1356cf55422 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java
@@ -3,6 +3,7 @@
 import com.google.common.collect.Lists;
 import com.google.api.client.util.ArrayMap;
 import edu.harvard.iq.dataverse.*;
+import static edu.harvard.iq.dataverse.api.AbstractApiBean.error;
 import edu.harvard.iq.dataverse.api.auth.AuthRequired;
 import edu.harvard.iq.dataverse.api.datadeposit.SwordServiceBean;
 import edu.harvard.iq.dataverse.api.dto.*;
@@ -23,6 +24,7 @@
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItemServiceBean;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import edu.harvard.iq.dataverse.engine.command.impl.*;
 import edu.harvard.iq.dataverse.pidproviders.PidProvider;
 import edu.harvard.iq.dataverse.pidproviders.PidUtil;
@@ -118,6 +120,9 @@ public class Dataverses extends AbstractApiBean {
 
     @EJB
     PermissionServiceBean permissionService;
+    
+    @EJB
+    TemplateServiceBean templateService;
 
     @EJB
     DataverseFeaturedItemServiceBean dataverseFeaturedItemServiceBean;
@@ -1989,6 +1994,21 @@ public Response getTemplates(@Context ContainerRequestContext crc, @PathParam("i
             return e.getResponse();
         }
     }
+    
+    @GET
+    @AuthRequired
+    @Path("/template/{id}")
+    public Response getTemplate(@Context ContainerRequestContext crc, @PathParam("id") Long templateId) {
+        try {
+            Template template = templateService.find(templateId);
+            if (template == null){
+                return error(Response.Status.NOT_FOUND, "Template with id " + templateId + " -  not found.");
+            }
+            return ok(jsonTemplate(execCommand(new GetTemplateCommand(createDataverseRequest(getRequestUser(crc)), template))));
+        } catch (WrappedResponse e) {
+            return e.getResponse();
+        }
+    }
 
     @POST
     @AuthRequired
@@ -2002,7 +2022,10 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
             } catch (JsonParseException ex) {
                 return error(Status.BAD_REQUEST, MessageFormat.format(BundleUtil.getStringFromBundle("dataverse.createTemplate.error.jsonParseMetadataFields"), ex.getMessage()));
             }
-            return ok(jsonTemplate(execCommand(new CreateTemplateCommand(newTemplateDTO.toTemplate(), createDataverseRequest(getRequestUser(crc)), dataverse, true))));
+            Template created = execCommand(new CreateTemplateCommand(newTemplateDTO.toTemplate(), createDataverseRequest(getRequestUser(crc)), dataverse, true));
+            
+            return created("/dataverses/template/" + created.getId(), jsonTemplate(created));
+        
         } catch (WrappedResponse e) {
             return e.getResponse();
         }
@@ -2036,6 +2059,27 @@ public Response setMetadataLanguage(@Context ContainerRequestContext crc, @PathP
         }, getRequestUser(crc));
     }
     
+    @Path("{id}/template")
+    @AuthRequired
+    @DELETE
+    public Response deleteTemplate(@Context ContainerRequestContext crc, @PathParam("id") long id) {
+
+        Template doomed = templateService.find(id);
+        if (doomed == null) {
+            return error(Response.Status.NOT_FOUND, "Template with id " + id + " -  not found.");
+        }
+
+        Dataverse dv = doomed.getDataverse();
+        List<Dataverse> dataverseWDefaultTemplate = templateService.findDataversesByDefaultTemplateId(doomed.getId());
+        try {
+            execCommand(new DeleteTemplateCommand(createDataverseRequest(getRequestUser(crc)), dv, doomed, dataverseWDefaultTemplate));
+        } catch (WrappedResponse wr) {
+            return handleWrappedResponse(wr);
+        }
+
+        return ok("Template " + doomed.getName() + " deleted.");
+    }
+    
     @GET
     @AuthRequired
     @Path("{identifier}/assignments/history")
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
index 69e19378b1a..96773f24ca9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
@@ -49,16 +49,15 @@ public Template execute(CommandContext ctxt) throws CommandException {
         }
 
         Template createdTemplate = ctxt.templates().save(template);
-        
         createdTemplate.setIsDefaultForDataverse(template.isIsDefaultForDataverse());
         if (initialize && createdTemplate.isIsDefaultForDataverse()) {
             dataverse.setDefaultTemplate(createdTemplate);
             ctxt.em().merge(dataverse);
-        }      
+        }
         
+        //Flush so that api response can include the id
         ctxt.em().flush();
         return createdTemplate;
-
     }
 
     private static void updateTermsOfUseAndAccess(CommandContext ctxt, Template template) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetTemplateCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetTemplateCommand.java
new file mode 100644
index 00000000000..9ac4128a151
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetTemplateCommand.java
@@ -0,0 +1,50 @@
+
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ *
+ * @author stephenkraffmiller
+ */
+public class GetTemplateCommand extends AbstractCommand<Template>  {
+    
+    private final Template template;
+    
+    public GetTemplateCommand (DataverseRequest aRequest, Template template){
+        super(aRequest, template.getDataverse());
+        this.template = template;
+    }
+
+
+    
+    @Override
+    public Template execute(CommandContext ctxt) throws CommandException {
+        return template;
+    }
+
+    @Override
+    public Map<String, Set<Permission>> getRequiredPermissions() {
+        //at least need add dataset if not published also - view unpublished
+        Set<Permission> requiredPermissions = new HashSet<>();
+
+        requiredPermissions.add(Permission.AddDataset);
+        if (!template.getDataverse().isReleased()) {
+            requiredPermissions.add(Permission.ViewUnpublishedDataverse);
+        }
+
+        return Collections.singletonMap("", requiredPermissions);
+
+    }
+    
+    
+}
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 1b908f63bfa..653d84fe09e 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2609,6 +2609,10 @@ public void testUpdateInputLevelDisplayOnCreateOverride() {
 
     @Test
     public void testCreateAndGetTemplates() throws JsonParseException  {
+        /*
+          Also Delete...and get single template
+        */
+        
         Response createUserResponse = UtilIT.createRandomUser();
         String apiToken = UtilIT.getApiTokenFromResponse(createUserResponse);
         String username = UtilIT.getUsernameFromResponse(createUserResponse);
@@ -2623,9 +2627,13 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
          */
         
         Response createDataverseResponse = UtilIT.createRandomDataverse(apiToken);
+        createDataverseResponse.prettyPrint();
         createDataverseResponse.then().assertThat().statusCode(CREATED.getStatusCode());
         String dataverseAlias = UtilIT.getAliasFromResponse(createDataverseResponse);
-
+        Integer dataverseId = UtilIT.getDataverseIdFromResponse(createDataverseResponse);
+        
+        System.out.print("dataverseId: " + dataverseId);
+        
         String newName = "New Test Dataverse Name";
         String newAffiliation = "New Test Dataverse Affiliation";
         String newDataverseType = Dataverse.DataverseType.TEACHING_COURSES.toString();
@@ -2644,6 +2652,10 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
         updateDataverseResponse.then().assertThat()
                 .statusCode(OK.getStatusCode());
 
+        Response publishDataverse = UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiToken);
+        assertEquals(200, publishDataverse.getStatusCode());
+        assertTrue(publishDataverse.prettyPrint().contains("isReleased\": true"));
+        
         // Create a template
 
         String jsonString = """
@@ -2681,8 +2693,11 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
                 jsonString,
                 apiToken
         );
+
+        createTemplateResponse.prettyPrint();
+        Long templateId = UtilIT.getTemplateIdFromResponse(createTemplateResponse);
         
-        createTemplateResponse.then().assertThat().statusCode(OK.getStatusCode())
+        createTemplateResponse.then().assertThat().statusCode(CREATED.getStatusCode())
                 .body("data.name", equalTo("Dataverse template"))
                 .body("data.isDefault", equalTo(true))
                 .body("data.usageCount", equalTo(0))
@@ -2724,12 +2739,59 @@ public void testCreateAndGetTemplates() throws JsonParseException  {
 
         // Templates retrieval should succeed if the secondary user has dataset creation permissions
 
+        
+        //set to super to update role 
         UtilIT.setSuperuserStatus(username, true);
+
         Response grantRoleResponse = UtilIT.grantRoleOnDataverse(dataverseAlias, DataverseRole.DS_CONTRIBUTOR, "@" + secondUsername, apiToken);
+        grantRoleResponse.prettyPrint();
         grantRoleResponse.then().assertThat().statusCode(OK.getStatusCode());
 
         getTemplateResponse = UtilIT.getTemplates(dataverseAlias, secondApiToken);
         getTemplateResponse.then().assertThat().statusCode(OK.getStatusCode());
+        
+        Response getTemplateByIdResponse = UtilIT.getTemplate(templateId.toString(), apiToken);
+        getTemplateByIdResponse.prettyPrint();
+        getTemplateByIdResponse.then().assertThat().statusCode(OK.getStatusCode());
+        
+        //guest user shouldn't get it
+        getTemplateByIdResponse = UtilIT.getTemplate(templateId.toString());
+        getTemplateByIdResponse.prettyPrint();
+        getTemplateByIdResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+        
+        Response deleteTemplateResponse = UtilIT.deleteTemplate(templateId.toString(), secondApiToken);
+        deleteTemplateResponse.prettyPrint();
+        deleteTemplateResponse.then().assertThat().statusCode(UNAUTHORIZED.getStatusCode());
+        
+        //set back to show super not needed for delete - just Edit Dataverse
+        UtilIT.setSuperuserStatus(username, false);
+        
+        String badId = "8675309";
+        
+        deleteTemplateResponse = UtilIT.deleteTemplate(badId, apiToken);
+        deleteTemplateResponse.prettyPrint();
+        deleteTemplateResponse.then().assertThat().statusCode(NOT_FOUND.getStatusCode());
+        
+        deleteTemplateResponse = UtilIT.deleteTemplate(templateId.toString(), apiToken);
+        deleteTemplateResponse.prettyPrint();
+        deleteTemplateResponse.then().assertThat().statusCode(OK.getStatusCode());
+        // back to super for cleanup
+        
+        UtilIT.setSuperuserStatus(username, true);
+        
+        Response deleteDataverse1Response = UtilIT.deleteDataverse(dataverseAlias, apiToken);
+        deleteDataverse1Response.prettyPrint();
+        assertEquals(200, deleteDataverse1Response.getStatusCode());
+        
+        Response deleteUserResponse = UtilIT.deleteUser(secondUsername);
+        deleteUserResponse.prettyPrint();
+        assertEquals(200, deleteUserResponse.getStatusCode());
+        
+        deleteUserResponse = UtilIT.deleteUser(username);
+        deleteUserResponse.prettyPrint();
+        assertEquals(200, deleteUserResponse.getStatusCode());
+        
+        
     }
 
     @Test
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
index f09b33a0b5b..3fe25cda604 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/UtilIT.java
@@ -337,6 +337,13 @@ static Integer getDataverseIdFromResponse(Response createDataverseResponse) {
         logger.info("Id found in create dataverse response: " + dataverseId);
         return dataverseId;
     }
+    
+    static Long getTemplateIdFromResponse(Response createTemplateResponse) {
+        JsonPath createdTemplate = JsonPath.from(createTemplateResponse.body().asString());
+        Long templateId = createdTemplate.getLong("data.id");
+        logger.info("Id found in create template response: " + templateId);
+        return templateId;
+    }
 
     static Integer getDatasetIdFromResponse(Response createDatasetResponse) {
         JsonPath createdDataset = JsonPath.from(createDatasetResponse.body().asString());
@@ -5128,6 +5135,12 @@ public static Response createTemplate(String dataverseAlias, String jsonString,
                 .body(jsonString)
                 .post("/api/dataverses/" + dataverseAlias + "/templates");
     }
+    
+    public static Response deleteTemplate(String id,  String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .delete("/api/dataverses/"+id+"/template");
+    }
 
     public static Response getTemplates(String dataverseAlias, String apiToken) {
         return given()
@@ -5136,6 +5149,19 @@ public static Response getTemplates(String dataverseAlias, String apiToken) {
                 .get("/api/dataverses/" + dataverseAlias + "/templates");
     }
     
+    public static Response getTemplate(String templateId) {
+        return given()
+                .contentType(ContentType.JSON)
+                .get("/api/dataverses/template/" + templateId);
+    }
+    
+    public static Response getTemplate(String templateId, String apiToken) {
+        return given()
+                .contentType(ContentType.JSON)
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .get("/api/dataverses/template/" + templateId);
+    }
+    
     /**
      * Gets the tool URL for a dataset with optional parameters
      * @param datasetId The ID of the dataset
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java
index 71bcbad98b8..baac3187fd8 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommandTest.java
@@ -6,6 +6,7 @@
 import edu.harvard.iq.dataverse.settings.JvmSettings;
 import edu.harvard.iq.dataverse.util.DatasetFieldUtil;
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import jakarta.persistence.EntityManager;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
 import edu.harvard.iq.dataverse.util.testing.JvmSetting;
@@ -32,6 +33,9 @@
 public class CreateTemplateCommandTest {
 
     private DataverseRequest dataverseRequestStub;
+    
+    @Mock
+    private EntityManager em;
 
     @Mock
     private CommandContext contextMock;
@@ -43,8 +47,6 @@ public class CreateTemplateCommandTest {
     private LicenseServiceBean licenseServiceBeanMock;
     @Mock
     private DataverseFieldTypeInputLevelServiceBean fieldTypeInputLevelServiceBeanMock;
-    @Mock
-    private EntityManager em;
 
     @Spy
     private Template templateSpy;
@@ -62,9 +64,11 @@ public void setUp() {
     @Test
     public void execute_shouldSaveTemplate_noInitialization() throws CommandException {
         // Create the command with initialization set to false
+        
+        Template savedTemplate = mock(Template.class);
+        when(templateServiceBeanStub.save(templateSpy)).thenReturn(savedTemplate);
 
         CreateTemplateCommand sut = new CreateTemplateCommand(templateSpy, dataverseRequestStub, dataverseMock, false);
-        Template savedTemplate = mock(Template.class);
         when(templateServiceBeanStub.save(templateSpy)).thenReturn(savedTemplate);
         // Act
         
@@ -86,11 +90,12 @@ public void execute_shouldInitializeAndSaveTemplate_withInitialization() throws
         when(contextMock.metadataBlocks()).thenReturn(metadataBlockServiceBeanMock);
         when(contextMock.licenses()).thenReturn(licenseServiceBeanMock);
         when(contextMock.fieldTypeInputLevels()).thenReturn(fieldTypeInputLevelServiceBeanMock);
+        Template savedTemplate = mock(Template.class);
 
+        when(templateServiceBeanStub.save(templateSpy)).thenReturn(savedTemplate);
         when(dataverseMock.getId()).thenReturn(42L);
         when(dataverseMock.isMetadataBlockRoot()).thenReturn(true);
                 
-        Template savedTemplate = mock(Template.class);
         when(templateServiceBeanStub.save(templateSpy)).thenReturn(savedTemplate);
 
         // Mock system metadata blocks
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteTemplateCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteTemplateCommandTest.java
new file mode 100644
index 00000000000..bdbcbb3a1aa
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/DeleteTemplateCommandTest.java
@@ -0,0 +1,93 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.*;
+import jakarta.persistence.EntityManager;
+import java.util.*;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class DeleteTemplateCommandTest {
+
+    @Mock
+    private CommandContext ctxt;
+
+    @Mock
+    private EntityManager em;
+
+    @Mock
+    private Dataverse editedDv;
+
+    @Mock
+    private Dataverse otherDv;
+
+    @Mock
+    private Template doomed;
+    
+    @Mock
+    private DataverseRequest dataverseRequest;
+
+
+
+    @BeforeEach
+    void setup() {
+        MockitoAnnotations.openMocks(this);
+        when(ctxt.em()).thenReturn(em);
+
+        List<Dataverse> dvWDefaultTemplate = new ArrayList<>();
+        DeleteTemplateCommand sut = new DeleteTemplateCommand(dataverseRequest, editedDv,doomed, dvWDefaultTemplate);
+        // Simulate that dvWDefaultTemplate has one dataverse with a template
+
+    }
+
+    @Test
+    void testExecute_MergesAndRemovesCorrectly() throws Exception {
+        // Arrange
+        Dataverse mergedDv = mock(Dataverse.class);
+        Template mergedTemplate = mock(Template.class);
+        List<Dataverse> dvWDefaultTemplate = new ArrayList<>();
+        dvWDefaultTemplate.add(otherDv);
+
+        when(em.merge(editedDv)).thenReturn(mergedDv);
+        when(em.merge(doomed)).thenReturn(mergedTemplate);
+        DeleteTemplateCommand sut = new DeleteTemplateCommand(dataverseRequest, editedDv, doomed, dvWDefaultTemplate);
+ 
+        // Act
+        Dataverse result = sut.execute(ctxt);
+
+        // Assert
+        verify(em).merge(editedDv);          // should merge edited dataverse
+        verify(em).merge(otherDv);           // should merge dvWDefaultTemplate items after clearing default template
+        verify(otherDv).setDefaultTemplate(null);
+        verify(em).merge(doomed);            // should merge doomed template
+        verify(em).remove(mergedTemplate);   // should remove merged template
+        assertEquals(mergedDv, result);      // return value is the merged dataverse
+    }
+
+    @Test
+    void testExecute_WhenEditedDvIsNull() throws Exception {
+        // Arrange
+        Dataverse nullDv = null;
+        List<Dataverse> dvWDefaultTemplate = new ArrayList<>();
+        DeleteTemplateCommand sut = new DeleteTemplateCommand(dataverseRequest, nullDv, doomed, dvWDefaultTemplate);
+ 
+        Template mergedTemplate = mock(Template.class);
+        when(em.merge(doomed)).thenReturn(mergedTemplate);
+
+        // Act
+        Dataverse result = sut.execute(ctxt);
+
+        // Assert
+        verify(em, never()).merge(any(Dataverse.class));
+        verify(em).merge(doomed);
+        verify(em).remove(mergedTemplate);
+        assertNull(result);
+    }
+}
+