'org:foo:1.0'()
        }

        buildFile << """
            dependencies {
                conf('org:foo:1.0!!')
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {
                expectGetMetadata()
                expectGetArtifact()
            }
        }
        run ':checkDeps'

        then:
        resolve.expectGraph {

                }
            }
        """

        when:
        repositoryInteractions {
            'org:test:1.0' {
                expectGetMetadata()
            }
        }

        then:
        fails 'checkDeps'

        //TODO: should pass as specified below
//        when:
//        repositoryInteractions {
//            'org:test:1.0' {
//                expectResolve()

            }
        }

    }

    def "can use a custom metadata provider"() {
        given:
        def supplierInteractions = withPerVersionStatusSupplier()

        when:
        repositoryInteractions {
            'group:projectA' {
                expectVersionListing()
                '1.2' {
                    expectResolve()
                }
            }
            'group:projectB' {

            'org:module:1.0'()
        }

        buildFile << """
            dependencies {
                conf 'org:module:1.0'
            }
        """

        when:
        repositoryInteractions {
            'org:module:1.0' {
                expectResolve()
            }
        }
        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {

                    attributes {
                        attribute(CUSTOM_ATTRIBUTE, 'test value')
                    }
                }
            }
        """

        when:
        repositoryInteractions {
            'org:test:1.0' {
                expectResolve()
            }
        }
        succeeds 'checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {

                      $rule
                      because "we like testB better"
                   }
                }
            }
        """

        when:
        repositoryInteractions {
            'org:testA:1.0' {
                expectGetMetadata()
            }
            'org:testB:1.0' {
                expectGetMetadata()
            }
        }
        fails ":checkDeps"

                        params(quality)
                    })
                }
                conf 'org.test:module:1.0'
            }
        """

        when:
        repositoryInteractions {
            'org.test:module:1.0' {
                expectGetMetadata()
                if (fixApplied) {
                    expectGetArtifact()
                }
            }
        }

                    capabilities {
                        requireCapability('org:feature-1')
                    }
                }
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {
                expectResolve()
                expectGetVariantArtifacts('feature1')
            }
        }
        succeeds 'checkDeps'

        then:

            dependencies.components.all(com.example.AddVariantRule)
        """

        then: "the variant added by the rule should be present and should be chosen as the resolution result"
        repositoryInteractions {
            group("org") {
                module("a") {
                    version("1") {
                        expectGetMetadata()
                        allowAll()
                    }

        }
    }

    void repository(@DelegatesTo(RemoteRepositorySpec) Closure<Void> spec) {
        spec.delegate = repoSpec
        spec()
    }

    void repositoryInteractions(HttpRepository.MetadataType metadataType = getRepositoryMetadataType(),
                                @DelegatesTo(RemoteRepositorySpec) Closure<Void> spec) {
        RemoteRepositorySpec.DEFINES_INTERACTIONS.set(true)