Java Code Examples for org.alfresco.service.cmr.repository.ContentWriter#getContentUrl()

/**
 * {@inheritDoc}
 */
@Override
public ContentWriter getWriter(final ContentContext context)
{
    final ContentWriter backingWriter = super.getWriter(context);

    if (TransactionSupportUtil.isActualTransactionActive())
    {
        // this is a new URL so register for rollback handling
        final Set<String> urlsToDelete = TransactionalResourceHelper.getSet(StoreConstants.KEY_POST_ROLLBACK_DELETION_URLS);
        urlsToDelete.add(backingWriter.getContentUrl());
    }

    final ContentWriter writer = new CompressingContentWriter(backingWriter.getContentUrl(), context, this.temporaryStore,
            backingWriter, this.compressionType, this.mimetypesToCompress);
    return writer;
}
 

@Test
public void testDeleteSimple() throws Exception
{
    ContentStore store = getStore();
    ContentWriter writer = getWriter();
    writer.putContent("Content for testDeleteSimple");
    String contentUrl = writer.getContentUrl();
    assertTrue("Content must now exist", store.exists(contentUrl));
    try
    {
        store.delete(contentUrl);
    }
    catch (UnsupportedOperationException e)
    {
        logger.warn("Store test testDeleteSimple not possible on " + store.getClass().getName());
        return;
    }
    assertFalse("Content must now be removed", store.exists(contentUrl));
}
 

@Test
public void testGeneralUse()
{
    for (int i = 0 ; i < 20; i++)
    {
        ContentContext contentContext = new ContentContext(null, null);
        ContentWriter writer = routingStore.getWriter(contentContext);
        String content = "This was generated by " + this.getClass().getName() + "#testGeneralUse number " + i;
        writer.putContent(content);
        // Check that it exists
        String contentUrl = writer.getContentUrl();
        checkForContent(contentUrl, content);
        
        // Now go direct to the routing store and check that it is able to find the appropriate URLs
        ContentReader reader = routingStore.getReader(contentUrl);
        assertNotNull("Null reader returned", reader);
        assertTrue("Reader should be onto live content", reader.exists());
    }
}
 

public void testStoreWillReadFromCacheWhenAvailable()
{
    final String content = "Content for " + getName() + " test.";
    
    // Write some content to the backing store.
    ContentWriter writer = backingStore.getWriter(ContentContext.NULL_CONTEXT);
    writer.putContent(content);
    final String contentUrl = writer.getContentUrl();
    
    // Read content using the CachingContentStore - will cause content to be cached.
    String retrievedContent = store.getReader(contentUrl).getContentString();
    assertEquals(content, retrievedContent);
    
    // Remove the original content from the backing store.
    backingStore.delete(contentUrl);
    assertFalse("Original content should have been deleted", backingStore.exists(contentUrl));
    
    // The cached version is still available.
    String contentAfterDelete = store.getReader(contentUrl).getContentString();
    assertEquals(content, contentAfterDelete);
}
 

/**
 * Get a writer and write a little bit of content before reading it.
 */
@Test
public void testSimpleUse()
{
    ContentStore store = getStore();
    String content = "Content for testSimpleUse";
    
    ContentWriter writer = store.getWriter(ContentStore.NEW_CONTENT_CONTEXT);
    assertNotNull("Writer may not be null", writer);
    // Ensure that the URL is available
    String contentUrlBefore = writer.getContentUrl();
    assertNotNull("Content URL may not be null for unused writer", contentUrlBefore);
    assertTrue("URL is not valid: " + contentUrlBefore, AbstractContentStore.isValidContentUrl(contentUrlBefore));
    // Write something
    writer.putContent(content);
    String contentUrlAfter = writer.getContentUrl();
    assertTrue("URL is not valid: " + contentUrlBefore, AbstractContentStore.isValidContentUrl(contentUrlAfter));
    assertEquals("The content URL may not change just because the writer has put content", contentUrlBefore, contentUrlAfter);
    // Get the readers
    ContentReader reader = store.getReader(contentUrlBefore);
    assertNotNull("Reader from store is null", reader);
    assertEquals(reader.getContentUrl(), writer.getContentUrl());
    String checkContent = reader.getContentString();
    assertEquals("Content is different", content, checkContent);
}
 

/**
 * Checks that the store disallows concurrent writers to be issued to the same URL.
 */
@SuppressWarnings("unused")
@Test
public void testConcurrentWriteDetection() throws Exception
{
    ByteBuffer buffer = ByteBuffer.wrap("Something".getBytes());
    ContentStore store = getStore();

    ContentContext firstContentCtx = ContentStore.NEW_CONTENT_CONTEXT;
    ContentWriter firstWriter = store.getWriter(firstContentCtx);
    String contentUrl = firstWriter.getContentUrl();

    ContentContext secondContentCtx = new ContentContext(null, contentUrl);
    try
    {
        ContentWriter secondWriter = store.getWriter(secondContentCtx);
        fail("Store must disallow more than one writer onto the same content URL: " + store);
    }
    catch (ContentExistsException e)
    {
        // expected
    }
}
 

@Before
public void before() throws Exception
{
    // create a store that uses a subdirectory of the temp directory
    File tempDir = TempFileProvider.getTempDir();
    store = new FileContentStore(ctx,
            tempDir.getAbsolutePath() +
            File.separatorChar +
            getName());
    // Put some content into it
    ContentWriter writer = store.getWriter(new ContentContext(null, null));
    writer.putContent("Content for getExistingContentUrl");
    this.contentUrl = writer.getContentUrl();
    // disallow random access
    store.setReadOnly(true);
}
 

@Test
public void unconfiguredWriteReadDelete() throws Exception
{
    final FileContentStore store = this.createDefaultStore();

    store.afterPropertiesSet();

    Assert.assertTrue("Store should support write", store.isWriteSupported());

    final String testText = generateText(SEED_PRNG.nextLong());
    final Date dateBeforeWrite = new Date();
    final ContentWriter writer = this.testIndividualWriteAndRead(store, testText);

    final String contentUrl = writer.getContentUrl();
    final DateFormat df = new SimpleDateFormat("yyyy/M/d/H/m", Locale.ENGLISH);
    df.setTimeZone(TimeZone.getDefault());
    final String expectedPattern = "^" + STORE_PROTOCOL + ContentStore.PROTOCOL_DELIMITER + df.format(dateBeforeWrite)
            + "/[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\\.bin$";
    Assert.assertTrue("Content URL did not match expected date-based pattern with UUID", contentUrl.matches(expectedPattern));

    Assert.assertTrue("Content should have been deleted", store.delete(contentUrl));
    final Path rootPath = this.storeFolder.toPath();
    final long subPathCount = TestUtilities.walk(rootPath, (stream) -> {
        return stream.filter((path) -> {
            return !path.equals(rootPath);
        }).count();
    }, FileVisitOption.FOLLOW_LINKS);
    Assert.assertEquals("Store path should not contain any elements after delete", 0, subPathCount);
}
 

@Test
public void dontDeleteEmptryDirs() throws Exception
{
    final FileContentStore store = this.createDefaultStore();
    store.setDeleteEmptyDirs(false);

    store.afterPropertiesSet();

    Assert.assertTrue("Store should support write", store.isWriteSupported());

    final String testText = generateText(SEED_PRNG.nextLong());
    final ContentWriter writer = this.testIndividualWriteAndRead(store, testText);

    final String contentUrl = writer.getContentUrl();
    Assert.assertTrue("Content should have been deleted", store.delete(contentUrl));
    final Path rootPath = this.storeFolder.toPath();
    final long subPathCount = TestUtilities.walk(rootPath, (stream) -> {
        return stream.filter((path) -> {
            return !path.equals(rootPath);
        }).count();
    }, FileVisitOption.FOLLOW_LINKS);
    Assert.assertNotEquals("Store path should contain additional elements after delete without allowing empty directory deletion", 0,
            subPathCount);

    final long filesCount = TestUtilities.walk(rootPath, (stream) -> {
        return stream.filter((path) -> {
            return path.toFile().isFile();
        }).count();
    }, FileVisitOption.FOLLOW_LINKS);
    Assert.assertEquals("Store path should not contain any content files after deletion", 0, filesCount);
}
 

public void testGetRawReader() throws Exception
{
    ContentReader reader = contentService.getRawReader("test://non-existence");
    assertNotNull("A reader is expected with content URL referencing no content", reader);
    assertFalse("Reader should not have any content", reader.exists());
    // Now write something
    ContentWriter writer = contentService.getWriter(contentNodeRef, ContentModel.PROP_CONTENT, false);
    writer.putContent("ABC from " + getName());
    // Try again
    String contentUrl = writer.getContentUrl();
    reader = contentService.getRawReader(contentUrl);
    assertNotNull("Expected reader for live, raw content", reader);
    assertEquals("Content sizes don't match", writer.getSize(), reader.getSize());
}
 

/**
 * {@inheritDoc}
 * <p>
 * This implementation creates some content in the store and returns the new content URL.
 */
protected String getExistingContentUrl()
{
    ContentWriter writer = getWriter();
    writer.putContent("Content for getExistingContentUrl");
    return writer.getContentUrl();
}
 

private String writeSingleFileInMB(int sizeInMb) throws IOException
{
    ContentWriter writer = store.getWriter(ContentContext.NULL_CONTEXT);
    File content = createFileOfSize(sizeInMb * 1024);
    writer.putContent(content);
    return writer.getContentUrl();
}
 

@Test
@Ignore
public void deleteEmptyParentsButNotSymbolicLinks() throws Exception
{
    this.linkedFolder = TestUtilities.createFolder();

    final DateFormat df = new SimpleDateFormat("yyyy/M/d", Locale.ENGLISH);
    df.setTimeZone(TimeZone.getDefault());
    final String relativePathForSymbolicLink = df.format(new Date());
    final String relativePathForFolder = relativePathForSymbolicLink.substring(0, relativePathForSymbolicLink.lastIndexOf('/'));
    final String linkName = relativePathForSymbolicLink.substring(relativePathForSymbolicLink.lastIndexOf('/') + 1);

    final Path folderForLink = Files.createDirectories(this.storeFolder.toPath().resolve(relativePathForFolder));
    final Path linkPath = folderForLink.resolve(linkName);
    Files.createSymbolicLink(linkPath, this.linkedFolder.toPath());

    final FileContentStore store = this.createDefaultStore();

    store.afterPropertiesSet();

    Assert.assertTrue("Store should support write", store.isWriteSupported());

    final String testText = generateText(SEED_PRNG.nextLong());
    final ContentWriter writer = this.testIndividualWriteAndRead(store, testText);
    final String contentUrl = writer.getContentUrl();
    Assert.assertTrue("Content should have been deleted", store.delete(contentUrl));

    final Path linkedRootPath = this.linkedFolder.toPath();
    final long linkedFolderSubPaths = TestUtilities.walk(linkedRootPath, (stream) -> {
        return stream.filter((path) -> {
            return !path.equals(linkedRootPath);
        }).count();
    }, FileVisitOption.FOLLOW_LINKS);
    Assert.assertEquals("Linked folder should not contain additional elements after delete", 0, linkedFolderSubPaths);

    Assert.assertTrue("Link should still exist after delete", Files.exists(linkPath));
}
 

@Test
public void wildcardContentURL() throws Exception
{
    final FileContentStore store = this.createDefaultStore();

    store.afterPropertiesSet();

    Assert.assertTrue("Store should support write", store.isWriteSupported());

    final String testText = generateText(SEED_PRNG.nextLong());
    final String dummyContentUrl = StoreConstants.WILDCARD_PROTOCOL + ContentStore.PROTOCOL_DELIMITER + "any/path/will/do";
    final String expectedContentUrl = STORE_PROTOCOL + ContentStore.PROTOCOL_DELIMITER + "any/path/will/do";
    final ContentWriter writer = this.testIndividualWriteAndRead(store, new ContentContext(null, dummyContentUrl), testText);

    final String contentUrl = writer.getContentUrl();
    Assert.assertEquals("Effective content URL did not match expected URL", expectedContentUrl, contentUrl);

    Assert.assertTrue("Wildcard-based content URL should have been reported as supported",
            store.isContentUrlSupported(dummyContentUrl));
    Assert.assertTrue("Wildcard-based content URL should have been reported as existing", store.exists(dummyContentUrl));

    final ContentReader reader = store.getReader(dummyContentUrl);
    Assert.assertNotNull("Wildcard-based content URL should have yielded a reader", reader);
    Assert.assertTrue("Wildcard-based content URL should have yielded a reader to existing content", reader.exists());
    final String readContent = reader.getContentString();
    Assert.assertEquals("Content read from reader for wildcard-based content URL did not match written content", testText, readContent);

    Assert.assertTrue("Content should have been deleted using wildcard-based content URL", store.delete(dummyContentUrl));
    Assert.assertFalse(
            "Content should not be reported as existing for explicit content URL after having been deleted via wildcard-based content URL",
            store.exists(contentUrl));
}
 

public void testAddContent() throws Exception
{
    ContentWriter writer = getWriter();
    writer.putContent(SOME_CONTENT);
    String contentUrl = writer.getContentUrl();
    
    checkForUrl(contentUrl, true);
}
 

@Test
public void primaryOnlyWrite() throws Exception
{
    final AggregatingContentStore aggregatingContentStore = new AggregatingContentStore();

    final FileContentStore store1 = new FileContentStore();
    store1.setRootDirectory(store1Folder.getAbsolutePath());
    store1.setProtocol(STORE_1_PROTOCOL);
    aggregatingContentStore.setPrimaryStore(store1);

    final FileContentStore store2 = new FileContentStore();
    store2.setRootDirectory(store2Folder.getAbsolutePath());
    store2.setProtocol(STORE_2_PROTOCOL);

    final FileContentStore store3 = new FileContentStore();
    store3.setRootDirectory(store3Folder.getAbsolutePath());
    store3.setProtocol(STORE_3_PROTOCOL);

    aggregatingContentStore.setSecondaryStores(Arrays.asList(store2, store3));

    store1.afterPropertiesSet();
    store2.afterPropertiesSet();
    store3.afterPropertiesSet();
    aggregatingContentStore.afterPropertiesSet();

    final String primaryText1 = generateText(SEED_PRNG.nextLong());
    final String primaryText2 = generateText(SEED_PRNG.nextLong());

    final ContentWriter primaryWriter1 = testIndividualWriteAndRead(aggregatingContentStore, primaryText1, STORE_1_PROTOCOL);

    final String contentUrl1 = primaryWriter1.getContentUrl();
    final String wildcardContentUrl = contentUrl1.replaceFirst(STORE_1_PROTOCOL, StoreConstants.WILDCARD_PROTOCOL);
    Assert.assertTrue("Aggregating content store did not write content to primary store", store1.exists(wildcardContentUrl));
    Assert.assertFalse("Aggregating content store wrote content to 1st secondcary store", store2.exists(wildcardContentUrl));
    Assert.assertFalse("Aggregating content store wrote content to 2nd secondcary store", store3.exists(wildcardContentUrl));

    final ContentReader reader1 = store1.getReader(wildcardContentUrl);
    Assert.assertTrue("Aggregating store did not return valid reader for content URL in primary store",
            reader1 != null && reader1.exists());
    Assert.assertEquals("Content retrieved from primary store does not match content written via aggregating store", primaryText1,
            reader1.getContentString());

    store1.setReadOnly(true);

    this.thrown.expect(UnsupportedOperationException.class);
    testIndividualWriteAndRead(aggregatingContentStore, primaryText2, STORE_1_PROTOCOL);
}
 

@Test
public void primaryOnlyDeletion() throws Exception
{
    final AggregatingContentStore aggregatingContentStore = new AggregatingContentStore();
    aggregatingContentStore.setDeleteContentFromSecondaryStores(false);

    // all stores need to use identical protocol in content URLs
    final FileContentStore store1 = new FileContentStore();
    store1.setRootDirectory(store1Folder.getAbsolutePath());
    store1.setProtocol(STORE_1_PROTOCOL);
    aggregatingContentStore.setPrimaryStore(store1);

    final FileContentStore store2 = new FileContentStore();
    store2.setRootDirectory(store2Folder.getAbsolutePath());
    store2.setProtocol(STORE_1_PROTOCOL);

    final FileContentStore store3 = new FileContentStore();
    store3.setRootDirectory(store3Folder.getAbsolutePath());
    store3.setProtocol(STORE_1_PROTOCOL);

    aggregatingContentStore.setSecondaryStores(Arrays.asList(store2, store3));

    store1.afterPropertiesSet();
    store2.afterPropertiesSet();
    store3.afterPropertiesSet();
    aggregatingContentStore.afterPropertiesSet();

    final String text = generateText(SEED_PRNG.nextLong());

    final ContentWriter primaryWriter = testIndividualWriteAndRead(aggregatingContentStore, text, STORE_1_PROTOCOL);
    final String contentUrl = primaryWriter.getContentUrl();

    // copy into secondary stores
    final String wildcardContentUrl = contentUrl.replaceFirst(STORE_1_PROTOCOL, StoreConstants.WILDCARD_PROTOCOL);
    final ContentWriter store2Writer = store2.getWriter(new ContentContext(null, wildcardContentUrl));
    store2Writer.putContent(primaryWriter.getReader());

    final ContentWriter store3Writer = store3.getWriter(new ContentContext(null, wildcardContentUrl));
    store3Writer.putContent(primaryWriter.getReader());

    final boolean deleted = aggregatingContentStore.delete(contentUrl);
    Assert.assertTrue("Aggregating content store did not report content as deleted", deleted);
    Assert.assertFalse("Primary store still contains deleted content", store1.exists(contentUrl));
    Assert.assertTrue("1st secondary store does not still contain content despite deletion not allowed for secondary stores",
            store2.exists(store2Writer.getContentUrl()));
    Assert.assertTrue("2nd secondary store does not still contain content despite deletion not allowed for secondary stores",
            store3.exists(store3Writer.getContentUrl()));
}
 

/**
 * Test checkIn
 */
@Test
public void testCheckIn()
{
    NodeRef workingCopy = checkout();
    
    // Test standard check-in
    Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
    versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version");        
    cociService.checkin(workingCopy, versionProperties);    
    
    // Test check-in with content
    NodeRef workingCopy3 = checkout();
    
    nodeService.setProperty(workingCopy3, PROP_NAME_QNAME, TEST_VALUE_2);
    nodeService.setProperty(workingCopy3, PROP2_QNAME, TEST_VALUE_3);
    ContentWriter tempWriter = this.contentService.getWriter(workingCopy3, ContentModel.PROP_CONTENT, false);
    assertNotNull(tempWriter);
    tempWriter.putContent(CONTENT_2);
    String contentUrl = tempWriter.getContentUrl();
    Map<String, Serializable> versionProperties3 = new HashMap<String, Serializable>();
    versionProperties3.put(Version.PROP_DESCRIPTION, "description");
    versionProperties3.put(VersionModel.PROP_VERSION_TYPE, VersionType.MAJOR);
    NodeRef origNodeRef = cociService.checkin(workingCopy3, versionProperties3, contentUrl, true);
    assertNotNull(origNodeRef);
    
    // Check the checked in content
    ContentReader contentReader = this.contentService.getReader(origNodeRef, ContentModel.PROP_CONTENT);
    assertNotNull(contentReader);
    assertEquals(CONTENT_2, contentReader.getContentString());
    
    // Check that the version history is correct
    Version version = this.versionService.getCurrentVersion(origNodeRef);
    assertNotNull(version);
    assertEquals("description", version.getDescription());
    assertEquals(VersionType.MAJOR, version.getVersionType());
    NodeRef versionNodeRef = version.getFrozenStateNodeRef();
    assertNotNull(versionNodeRef);
    
    // Check the verioned content
    ContentReader versionContentReader = this.contentService.getReader(versionNodeRef, ContentModel.PROP_CONTENT);
    assertNotNull(versionContentReader);    
    assertEquals(CONTENT_2, versionContentReader.getContentString());
    
    // Check that the name is not updated during the check-in
    assertEquals(TEST_VALUE_2, nodeService.getProperty(versionNodeRef, PROP_NAME_QNAME));
    assertEquals(TEST_VALUE_2, nodeService.getProperty(origNodeRef, PROP_NAME_QNAME));
    
    // Check that the other properties are updated during the check-in
    assertEquals(TEST_VALUE_3, nodeService.getProperty(versionNodeRef, PROP2_QNAME));
    assertEquals(TEST_VALUE_3, nodeService.getProperty(origNodeRef, PROP2_QNAME));
    
    // Cancel the check out after is has been left checked out
    cociService.cancelCheckout(workingCopy3);
    
    // Test keep checked out flag
    NodeRef workingCopy2 = checkout();        
    Map<String, Serializable> versionProperties2 = new HashMap<String, Serializable>();
    versionProperties2.put(Version.PROP_DESCRIPTION, "Another version test");        
    this.cociService.checkin(workingCopy2, versionProperties2, null, true);
    this.cociService.checkin(workingCopy2, new HashMap<String, Serializable>(), null, true);    
}
 

@Test
public void readAggregation() throws Exception
{
    final AggregatingContentStore aggregatingContentStore = new AggregatingContentStore();

    final FileContentStore store1 = new FileContentStore();
    store1.setRootDirectory(store1Folder.getAbsolutePath());
    store1.setProtocol(STORE_1_PROTOCOL);
    aggregatingContentStore.setPrimaryStore(store1);

    final FileContentStore store2 = new FileContentStore();
    store2.setRootDirectory(store2Folder.getAbsolutePath());
    store2.setProtocol(STORE_2_PROTOCOL);

    final FileContentStore store3 = new FileContentStore();
    store3.setRootDirectory(store3Folder.getAbsolutePath());
    store3.setProtocol(STORE_3_PROTOCOL);

    aggregatingContentStore.setSecondaryStores(Arrays.asList(store2, store3));

    store1.afterPropertiesSet();
    store2.afterPropertiesSet();
    store3.afterPropertiesSet();
    aggregatingContentStore.afterPropertiesSet();

    final String textStore1 = generateText(SEED_PRNG.nextLong());
    final String textStore2 = generateText(SEED_PRNG.nextLong());
    final String textStore3 = generateText(SEED_PRNG.nextLong());

    {
        final ContentWriter store1Writer = testIndividualWriteAndRead(store1, textStore1, STORE_1_PROTOCOL);

        final String contentUrl1 = store1Writer.getContentUrl();
        Assert.assertTrue("Aggregating store does not support URL of primary store",
                aggregatingContentStore.isContentUrlSupported(contentUrl1));
        Assert.assertTrue("Aggregating store claims content URL of primary store does not exist",
                aggregatingContentStore.exists(contentUrl1));

        final ContentReader reader1 = aggregatingContentStore.getReader(contentUrl1);
        Assert.assertTrue("Aggregating store did not return valid reader for content URL in primary store",
                reader1 != null && reader1.exists());
        Assert.assertEquals("Content retrieved via aggregating store does not match content in primary store", textStore1,
                reader1.getContentString());
    }

    {
        final ContentWriter store2Writer = testIndividualWriteAndRead(store2, textStore2, STORE_2_PROTOCOL);

        final String contentUrl2 = store2Writer.getContentUrl();
        Assert.assertTrue("Aggregating store does not support URL of 1st secondary store",
                aggregatingContentStore.isContentUrlSupported(contentUrl2));
        Assert.assertTrue("Aggregating store claims content URL of 1st secondary store does not exist",
                aggregatingContentStore.exists(contentUrl2));

        final ContentReader reader2 = aggregatingContentStore.getReader(contentUrl2);
        Assert.assertTrue("Aggregating store did not return valid reader for content URL in 1st secondary store",
                reader2 != null && reader2.exists());
        Assert.assertEquals("Content retrieved via aggregating store does not match content in 1st secondary store", textStore2,
                reader2.getContentString());
    }

    {
        final ContentWriter store3Writer = testIndividualWriteAndRead(store3, textStore3, STORE_3_PROTOCOL);

        final String contentUrl3 = store3Writer.getContentUrl();
        Assert.assertTrue("Aggregating store does not support URL of 2nd secondary store",
                aggregatingContentStore.isContentUrlSupported(contentUrl3));
        Assert.assertTrue("Aggregating store claims content URL of 2nd secondary store does not exist",
                aggregatingContentStore.exists(contentUrl3));

        final ContentReader reader3 = aggregatingContentStore.getReader(contentUrl3);
        Assert.assertTrue("Aggregating store did not return valid reader for content URL in 2nd secondary store",
                reader3 != null && reader3.exists());
        Assert.assertEquals("Content retrieved via aggregating store does not match content in 2nd secondary store", textStore3,
                reader3.getContentString());
    }
}
 

@Test
public void defaultSecondaryStoreDeletionWithPartialReadOnlyStores() throws Exception
{
    final AggregatingContentStore aggregatingContentStore = new AggregatingContentStore();

    // all stores need to use identical protocol in content URLs
    final FileContentStore store1 = new FileContentStore();
    store1.setRootDirectory(store1Folder.getAbsolutePath());
    store1.setProtocol(STORE_1_PROTOCOL);
    aggregatingContentStore.setPrimaryStore(store1);

    final FileContentStore store2 = new FileContentStore();
    store2.setRootDirectory(store2Folder.getAbsolutePath());
    store2.setProtocol(STORE_1_PROTOCOL);

    final FileContentStore store3 = new FileContentStore();
    store3.setRootDirectory(store3Folder.getAbsolutePath());
    store3.setProtocol(STORE_1_PROTOCOL);

    aggregatingContentStore.setSecondaryStores(Arrays.asList(store2, store3));

    store1.afterPropertiesSet();
    store2.afterPropertiesSet();
    store3.afterPropertiesSet();
    aggregatingContentStore.afterPropertiesSet();

    final String text = generateText(SEED_PRNG.nextLong());

    final ContentWriter primaryWriter = testIndividualWriteAndRead(aggregatingContentStore, text, STORE_1_PROTOCOL);
    final String contentUrl = primaryWriter.getContentUrl();

    // copy into secondary stores
    final String wildcardContentUrl = contentUrl.replaceFirst(STORE_1_PROTOCOL, StoreConstants.WILDCARD_PROTOCOL);
    final ContentWriter store2Writer = store2.getWriter(new ContentContext(null, wildcardContentUrl));
    store2Writer.putContent(primaryWriter.getReader());

    final ContentWriter store3Writer = store3.getWriter(new ContentContext(null, wildcardContentUrl));
    store3Writer.putContent(primaryWriter.getReader());

    // mark 2nd secondary store as read-only
    store3.setReadOnly(true);

    final boolean deleted = aggregatingContentStore.delete(contentUrl);
    Assert.assertTrue("Aggregating content store did not report content as deleted", deleted);
    Assert.assertFalse("Primary store still contains deleted content", store1.exists(contentUrl));
    Assert.assertFalse("1st secondary store still contains deleted content", store2.exists(store2Writer.getContentUrl()));
    Assert.assertTrue("2nd secondary store does not still contain content despite store being read-only",
            store3.exists(store3Writer.getContentUrl()));
}