return repositoryId + ":" + artifactId;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof ArtifactAtRepositoryKey)) {
            return false;
        }
        ArtifactAtRepositoryKey other = (ArtifactAtRepositoryKey) o;
        return repositoryId.equals(other.repositoryId) && artifactId.equals(other.artifactId);
    }

    @Override
    public int hashCode() {

    }

    @Override
    public void store(ArtifactAtRepositoryKey key, File artifactFile, HashCode moduleDescriptorHash) {
        operationShouldNotHaveBeenCalled();
    }

    @Override
    public void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash) {
        operationShouldNotHaveBeenCalled();
    }

    }

    @Override
    public void storeMissing(ArtifactAtRepositoryKey key, List<String> attemptedLocations, HashCode descriptorHash) {
        writableCache.storeMissing(key, attemptedLocations, descriptorHash);
    }

    @Nullable
    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {
        CachedArtifact lookup = writableCache.lookup(key);
        if (lookup != null) {

     */
    void store(ArtifactAtRepositoryKey key, File artifactFile, HashCode moduleDescriptorHash);

    /**
     * Record that the artifact with the given key was missing.
     *  @param key The key to cache this resolution under in the index.
     * @param descriptorHash The SHA1 hash of the related moduleDescriptor
     */

import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class InMemoryModuleArtifactCache implements ModuleArtifactCache {
    private final Map<ArtifactAtRepositoryKey, CachedArtifact> inMemoryCache = new ConcurrentHashMap<>();
    private final BuildCommencedTimeProvider timeProvider;
    private final ModuleArtifactCache delegate;

    }

    @Override
    public CachedArtifact lookup(ArtifactAtRepositoryKey key) {
        assertKeyNotNull(key);

        return super.lookup(key);
    }

    private static class ArtifactAtRepositoryKeySerializer implements Serializer<ArtifactAtRepositoryKey> {
        private final Serializer<ComponentArtifactIdentifier> artifactIdSerializer;

    def "storing null artifactFile not supported"() {
        given:
        def key = new ArtifactAtRepositoryKey("RepoID", Stub(ModuleComponentArtifactIdentifier))

        when:
        index.store(key, null, TestHashCodes.hashCodeFrom(0))

        then:
        def e = thrown(IllegalArgumentException)

        def moduleSource = Stub(ModuleDescriptorHashModuleSource) {
            getDescriptorHash() >> descriptorHash
        }

        ArtifactAtRepositoryKey atRepositoryKey = new ArtifactAtRepositoryKey("repo-id", artifactId)

        when:
        repo.remoteAccess.resolveArtifact(artifact, ImmutableModuleSources.of(moduleSource), result)

        then:

import java.nio.file.Path

class TwoStageModuleArtifactCacheTest extends Specification {
    Path readOnlyPath = Stub(Path)
    File artifact = Stub(File)
    HashCode hashCode = Stub(HashCode)
    def key = Stub(ArtifactAtRepositoryKey)

    def readCache = Mock(ModuleArtifactCache)
    def writeCache = Mock(ModuleArtifactCache)

    @Subject
    def twoStageCache = new TwoStageModuleArtifactCache(readOnlyPath, readCache, writeCache)

    }

    private String cacheKey(ArtifactType artifactType) {
        return "artifacts:" + artifactType.name();
    }

    private ArtifactAtRepositoryKey artifactCacheKey(ComponentArtifactIdentifier id) {
        return new ArtifactAtRepositoryKey(delegate.getId(), id);
    }