return someheader


def get_something_else(*, someheader: str = Depends(get_header)):
    return f"{someheader}123"


@app.get("/")
def get_deps(dep1: str = Depends(get_header), dep2: str = Depends(get_something_else)):
    return {"dep1": dep1, "dep2": dep2}


client = TestClient(app)

schema = {
    "components": {
        "schemas": {
            "HTTPValidationError": {

        root.children.addAll(dep1, dep2)
        dep1.children.addAll(dep11)
        dep2.children.addAll(dep1, dep22)

        when:
        renderer.render([root])
        renderer.complete()

        then:
        textOutput.value.readLines() == [
                '+--- dep1',
                '|    \\--- dep1.1',
                '\\--- dep2',
                '     +--- dep1 (*)',
                '     \\--- dep2.2',

        then:
        deps*.requested.group == ['dep1', 'dep3', 'dep2', 'dep3']

        and:
        modules*.id.group == ['root', 'dep1', 'dep3', 'dep2']
    }

    def "deals with dependency cycles"() {
        given:
        // a->b->a
        def root = newModule('a', 'a', '1')
        def dep1 = newDependency('b', 'b', '1')
        root.addDependency(dep1)

        when:
        dependencyHandler.platform(dep1)

        then:
        1 * dependencyFactory.createDependency(dep1) >> dep1
        dep1.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE).name == 'platform'
        dep1.isEndorsingStrictVersions()

        when:
        dependencyHandler.platform(dep2) { }

        then:

! go list -m example.com/dep
stderr 'go: conflicting replacements for example.com/dep@v1.0.0:\n\t'$PWD${/}'dep1\n\t'$PWD${/}'dep2\nuse "go work edit -replace example.com/dep@v1.0.0=\[override\]" to resolve'
go work edit -replace example.com/dep@v1.0.0=./dep1
go list -m example.com/dep
stdout 'example.com/dep v1.0.0 => ./dep1'

-- foo --
-- go.work --
use m
use n
-- m/go.mod --
module example.com/m

        def dep1 = Stub(Node)
        def dep2 = Stub(Node)

        given:
        _ * node.shouldContinueExecution(_) >> true

        when:
        set.addDependency(dep1)
        set.addDependency(dep2)

        then:
        set.getState(node) == Node.DependenciesState.NOT_COMPLETE

        when:
        set.onNodeComplete(node, dep1)

        then:

"""
    }

    def "maintains graph in byte stream"() {
        def root = rootNode(1, "org", "root", "1.0")
        def selector1 = selector(1, "org", "dep1", "2.0")
        def selector2 = selector(2, "org", "dep2", "3.0")
        def dep1 = node(2, "org", "dep1", "2.0", of(CONFLICT_RESOLUTION))
        root.outgoingEdges >> [
                dep(selector1, 1, 2),
                dep(selector2, 1, new RuntimeException("Boo!"))

		{
			[]madmin.PeerInfo{
				{Endpoint: "minio1:9000", Name: "minio1", DeploymentID: "dep1"},
				{Endpoint: "minio2:9000", Name: "minio2", DeploymentID: "dep2"},
				{Endpoint: "minio3:9000", Name: "minio3", DeploymentID: "dep3"},
			},
			set.CreateStringSet("dep1", "dep2", "dep3"),
			set.CreateStringSet("dep1"),
			[]string{"minio2", "minio3"},
		},
		// Test2: new site added that is not in replicated setup
		{

        /*
        Dependency dep1 = new Dependency();
        dep1.setGroupId( "test" );
        dep1.setArtifactId( "test-artifact" );
        dep1.setVersion( "1" );
        dep1.setType( "jar" );

        Exclusion exc = new Exclusion();
        exc.setGroupId( "test" );
        exc.setArtifactId( "test-artifact3" );

        dep1.addExclusion( exc );

        Dependency dep2 = new Dependency();

        when:
        def dep1 = createDependency("group1", "name1", "version1", null)
        def dep2 = createDependency("group1", "name1", "version1", null)
        dep2.addDependency(Mock(ModuleDependency))

        then:
        dep1 != dep2
        !dep1.contentEquals(dep2)
        !dep2.contentEquals(dep1)
    }