Fnlb was moved to its own repo: fnproject/lb (#702)

* Fnlb was moved to its own repo: fnproject/lb

* Clean up fnlb leftovers

* Newer deps

vendor/github.com/go-openapi/spec/expander_test.go

@@ -17,6 +17,7 @@ package spec
 import (
 	"encoding/json"
 	"io/ioutil"
+	"log"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -34,6 +35,45 @@ func jsonDoc(path string) (json.RawMessage, error) {
 	return json.RawMessage(data), nil
 }
 
+// tests that paths are normalized correctly
+func TestNormalizePaths(t *testing.T) {
+	testCases := []struct {
+		refPath   string
+		base      string
+		expOutput string
+	}{
+		{
+			// file basePath, absolute refPath
+			refPath:   "/another/base/path.json#/definitions/Pet",
+			base:      "/base/path.json",
+			expOutput: "/another/base/path.json#/definitions/Pet",
+		},
+		{
+			// file basePath, relative refPath
+			refPath:   "another/base/path.json#/definitions/Pet",
+			base:      "/base/path.json",
+			expOutput: "/base/another/base/path.json#/definitions/Pet",
+		},
+		{
+			// http basePath, absolute refPath
+			refPath:   "http://www.anotherexample.com/another/base/path/swagger.json#/definitions/Pet",
+			base:      "http://www.example.com/base/path/swagger.json",
+			expOutput: "http://www.anotherexample.com/another/base/path/swagger.json#/definitions/Pet",
+		},
+		{
+			// http basePath, relative refPath
+			refPath:   "another/base/path/swagger.json#/definitions/Pet",
+			base:      "http://www.example.com/base/path/swagger.json",
+			expOutput: "http://www.example.com/base/path/another/base/path/swagger.json#/definitions/Pet",
+		},
+	}
+
+	for _, tcase := range testCases {
+		out := normalizePaths(tcase.refPath, tcase.base)
+		assert.Equal(t, tcase.expOutput, out)
+	}
+}
+
 func TestExpandsKnownRef(t *testing.T) {
 	schema := RefProperty("http://json-schema.org/draft-04/schema#")
 	if assert.NoError(t, ExpandSchema(schema, nil, nil)) {
@@ -71,6 +111,11 @@ func TestSpecExpansion(t *testing.T) {
 	specDoc, err := jsonDoc("fixtures/expansion/all-the-things.json")
 	assert.NoError(t, err)
 
+	specPath, _ := absPath("fixtures/expansion/all-the-things.json")
+	opts := &ExpandOptions{
+		RelativeBase: specPath,
+	}
+
 	spec = new(Swagger)
 	err = json.Unmarshal(specDoc, spec)
 	assert.NoError(t, err)
@@ -83,7 +128,7 @@ func TestSpecExpansion(t *testing.T) {
 	tagParam := spec.Parameters["tag"]
 	idParam := spec.Parameters["idParam"]
 
-	err = ExpandSpec(spec, nil)
+	err = ExpandSpec(spec, opts)
 	assert.NoError(t, err)
 
 	assert.Equal(t, tagParam, spec.Parameters["query"])
@@ -106,35 +151,57 @@ func TestSpecExpansion(t *testing.T) {
 	assert.Equal(t, errorModel, *pi.Delete.Responses.Default.Schema)
 }
 
+func TestResolveRef(t *testing.T) {
+	var root interface{}
+	err := json.Unmarshal([]byte(PetStore20), &root)
+	assert.NoError(t, err)
+	ref, err := NewRef("#/definitions/Category")
+	assert.NoError(t, err)
+	sch, err := ResolveRef(root, &ref)
+	assert.NoError(t, err)
+	b, _ := sch.MarshalJSON()
+	assert.JSONEq(t, `{"id":"Category","properties":{"id":{"type":"integer","format":"int64"},"name":{"type":"string"}}}`, string(b))
+}
+
 func TestResponseExpansion(t *testing.T) {
 	specDoc, err := jsonDoc("fixtures/expansion/all-the-things.json")
 	assert.NoError(t, err)
 
+	basePath, err := absPath("fixtures/expansion/all-the-things.json")
+	assert.NoError(t, err)
+
 	spec := new(Swagger)
 	err = json.Unmarshal(specDoc, spec)
 	assert.NoError(t, err)
 
-	resolver, err := defaultSchemaLoader(spec, nil, nil, nil)
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	assert.NoError(t, err)
 
 	resp := spec.Responses["anotherPet"]
-	expected := spec.Responses["petResponse"]
+	r := spec.Responses["petResponse"]
+	err = expandResponse(&r, resolver, basePath)
+	assert.NoError(t, err)
+	expected := r
 
-	err = expandResponse(&resp, resolver)
+	err = expandResponse(&resp, resolver, basePath)
+	b, _ := resp.MarshalJSON()
+	log.Printf(string(b))
+	b, _ = expected.MarshalJSON()
+	log.Printf(string(b))
 	assert.NoError(t, err)
 	assert.Equal(t, expected, resp)
 
 	resp2 := spec.Paths.Paths["/"].Get.Responses.Default
 	expected = spec.Responses["stringResponse"]
 
-	err = expandResponse(resp2, resolver)
+	err = expandResponse(resp2, resolver, basePath)
 	assert.NoError(t, err)
 	assert.Equal(t, expected, *resp2)
 
 	resp = spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200]
 	expected = spec.Responses["petResponse"]
 
-	err = expandResponse(&resp, resolver)
+	err = expandResponse(&resp, resolver, basePath)
 	assert.NoError(t, err)
 	// assert.Equal(t, expected, resp)
 }
@@ -144,11 +211,16 @@ func TestIssue3(t *testing.T) {
 	specDoc, err := jsonDoc("fixtures/expansion/overflow.json")
 	assert.NoError(t, err)
 
+	specPath, _ := absPath("fixtures/expansion/overflow.json")
+	opts := &ExpandOptions{
+		RelativeBase: specPath,
+	}
+
 	err = json.Unmarshal(specDoc, spec)
 	assert.NoError(t, err)
 
 	assert.NotPanics(t, func() {
-		err = ExpandSpec(spec, nil)
+		err = ExpandSpec(spec, opts)
 		assert.NoError(t, err)
 	}, "Calling expand spec with circular refs, should not panic!")
 }
@@ -161,20 +233,23 @@ func TestParameterExpansion(t *testing.T) {
 	err = json.Unmarshal(paramDoc, spec)
 	assert.NoError(t, err)
 
-	resolver, err := defaultSchemaLoader(spec, nil, nil, nil)
+	basePath, err := absPath("fixtures/expansion/params.json")
+	assert.NoError(t, err)
+
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	assert.NoError(t, err)
 
 	param := spec.Parameters["query"]
 	expected := spec.Parameters["tag"]
 
-	err = expandParameter(&param, resolver)
+	err = expandParameter(&param, resolver, basePath)
 	assert.NoError(t, err)
 	assert.Equal(t, expected, param)
 
 	param = spec.Paths.Paths["/cars/{id}"].Parameters[0]
 	expected = spec.Parameters["id"]
 
-	err = expandParameter(&param, resolver)
+	err = expandParameter(&param, resolver, basePath)
 	assert.NoError(t, err)
 	assert.Equal(t, expected, param)
 }
@@ -183,16 +258,18 @@ func TestCircularRefsExpansion(t *testing.T) {
 	carsDoc, err := jsonDoc("fixtures/expansion/circularRefs.json")
 	assert.NoError(t, err)
 
+	basePath, _ := absPath("fixtures/expansion/circularRefs.json")
+
 	spec := new(Swagger)
 	err = json.Unmarshal(carsDoc, spec)
 	assert.NoError(t, err)
 
-	resolver, err := defaultSchemaLoader(spec, nil, nil, nil)
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	assert.NoError(t, err)
 	schema := spec.Definitions["car"]
 
 	assert.NotPanics(t, func() {
-		_, err = expandSchema(schema, []string{"#/definitions/car"}, resolver)
+		_, err = expandSchema(schema, []string{"#/definitions/car"}, resolver, basePath)
 		assert.NoError(t, err)
 	}, "Calling expand schema with circular refs, should not panic!")
 }
@@ -201,6 +278,8 @@ func TestContinueOnErrorExpansion(t *testing.T) {
 	missingRefDoc, err := jsonDoc("fixtures/expansion/missingRef.json")
 	assert.NoError(t, err)
 
+	specPath, _ := absPath("fixtures/expansion/missingRef.json")
+
 	testCase := struct {
 		Input    *Swagger `json:"input"`
 		Expected *Swagger `json:"expected"`
@@ -210,9 +289,12 @@ func TestContinueOnErrorExpansion(t *testing.T) {
 
 	opts := &ExpandOptions{
 		ContinueOnError: true,
+		RelativeBase:    specPath,
 	}
 	err = ExpandSpec(testCase.Input, opts)
 	assert.NoError(t, err)
+	b, _ := testCase.Input.MarshalJSON()
+	log.Printf(string(b))
 	assert.Equal(t, testCase.Input, testCase.Expected, "Should continue expanding spec when a definition can't be found.")
 
 	doc, err := jsonDoc("fixtures/expansion/missingItemRef.json")
@@ -230,12 +312,18 @@ func TestIssue415(t *testing.T) {
 	doc, err := jsonDoc("fixtures/expansion/clickmeter.json")
 	assert.NoError(t, err)
 
+	specPath, _ := absPath("fixtures/expansion/clickmeter.json")
+
+	opts := &ExpandOptions{
+		RelativeBase: specPath,
+	}
+
 	spec := new(Swagger)
 	err = json.Unmarshal(doc, spec)
 	assert.NoError(t, err)
 
 	assert.NotPanics(t, func() {
-		err = ExpandSpec(spec, nil)
+		err = ExpandSpec(spec, opts)
 		assert.NoError(t, err)
 	}, "Calling expand spec with response schemas that have circular refs, should not panic!")
 }
@@ -244,12 +332,18 @@ func TestCircularSpecExpansion(t *testing.T) {
 	doc, err := jsonDoc("fixtures/expansion/circularSpec.json")
 	assert.NoError(t, err)
 
+	specPath, _ := absPath("fixtures/expansion/circularSpec.json")
+
+	opts := &ExpandOptions{
+		RelativeBase: specPath,
+	}
+
 	spec := new(Swagger)
 	err = json.Unmarshal(doc, spec)
 	assert.NoError(t, err)
 
 	assert.NotPanics(t, func() {
-		err = ExpandSpec(spec, nil)
+		err = ExpandSpec(spec, opts)
 		assert.NoError(t, err)
 	}, "Calling expand spec with circular refs, should not panic!")
 }
@@ -258,11 +352,13 @@ func TestItemsExpansion(t *testing.T) {
 	carsDoc, err := jsonDoc("fixtures/expansion/schemas2.json")
 	assert.NoError(t, err)
 
+	basePath, _ := absPath("fixtures/expansion/schemas2.json")
+
 	spec := new(Swagger)
 	err = json.Unmarshal(carsDoc, spec)
 	assert.NoError(t, err)
 
-	resolver, err := defaultSchemaLoader(spec, nil, nil, nil)
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	assert.NoError(t, err)
 
 	schema := spec.Definitions["car"]
@@ -270,7 +366,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.NotEmpty(t, oldBrand.Items.Schema.Ref.String())
 	assert.NotEqual(t, spec.Definitions["brand"], oldBrand)
 
-	_, err = expandSchema(schema, []string{"#/definitions/car"}, resolver)
+	_, err = expandSchema(schema, []string{"#/definitions/car"}, resolver, basePath)
 	assert.NoError(t, err)
 
 	newBrand := schema.Properties["brand"]
@@ -280,25 +376,25 @@ func TestItemsExpansion(t *testing.T) {
 	schema = spec.Definitions["truck"]
 	assert.NotEmpty(t, schema.Items.Schema.Ref.String())
 
-	s, err := expandSchema(schema, []string{"#/definitions/truck"}, resolver)
+	s, err := expandSchema(schema, []string{"#/definitions/truck"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Items.Schema.Ref.String())
 	assert.Equal(t, spec.Definitions["car"], *schema.Items.Schema)
 
 	sch := new(Schema)
-	_, err = expandSchema(*sch, []string{""}, resolver)
+	_, err = expandSchema(*sch, []string{""}, resolver, basePath)
 	assert.NoError(t, err)
 
 	schema = spec.Definitions["batch"]
-	s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Items.Schema.Items.Schema.Ref.String())
 	assert.Equal(t, *schema.Items.Schema.Items.Schema, spec.Definitions["brand"])
 
 	schema = spec.Definitions["batch2"]
-	s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Items.Schemas[0].Items.Schema.Ref.String())
@@ -307,7 +403,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *schema.Items.Schemas[1].Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["allofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AllOf[0].Items.Schema.Ref.String())
@@ -316,7 +412,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *schema.AllOf[1].Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["anyofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AnyOf[0].Items.Schema.Ref.String())
@@ -325,7 +421,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *schema.AnyOf[1].Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["oneofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.OneOf[0].Items.Schema.Ref.String())
@@ -334,28 +430,28 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *schema.OneOf[1].Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["notSomething"]
-	s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Not.Items.Schema.Ref.String())
 	assert.Equal(t, *schema.Not.Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withAdditional"]
-	s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AdditionalProperties.Schema.Items.Schema.Ref.String())
 	assert.Equal(t, *schema.AdditionalProperties.Schema.Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withAdditionalItems"]
-	s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AdditionalItems.Schema.Items.Schema.Ref.String())
 	assert.Equal(t, *schema.AdditionalItems.Schema.Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withPattern"]
-	s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop := schema.PatternProperties["^x-ab"]
@@ -363,7 +459,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *prop.Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["deps"]
-	s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop2 := schema.Dependencies["something"]
@@ -371,7 +467,7 @@ func TestItemsExpansion(t *testing.T) {
 	assert.Equal(t, *prop2.Schema.Items.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["defined"]
-	s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop = schema.Definitions["something"]
@@ -383,11 +479,13 @@ func TestSchemaExpansion(t *testing.T) {
 	carsDoc, err := jsonDoc("fixtures/expansion/schemas1.json")
 	assert.NoError(t, err)
 
+	basePath, _ := absPath("fixtures/expansion/schemas1.json")
+
 	spec := new(Swagger)
 	err = json.Unmarshal(carsDoc, spec)
 	assert.NoError(t, err)
 
-	resolver, err := defaultSchemaLoader(spec, nil, nil, nil)
+	resolver, err := defaultSchemaLoader(spec, nil, nil)
 	assert.NoError(t, err)
 
 	schema := spec.Definitions["car"]
@@ -395,7 +493,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.NotEmpty(t, oldBrand.Ref.String())
 	assert.NotEqual(t, spec.Definitions["brand"], oldBrand)
 
-	s, err := expandSchema(schema, []string{"#/definitions/car"}, resolver)
+	s, err := expandSchema(schema, []string{"#/definitions/car"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 
@@ -406,25 +504,25 @@ func TestSchemaExpansion(t *testing.T) {
 	schema = spec.Definitions["truck"]
 	assert.NotEmpty(t, schema.Ref.String())
 
-	s, err = expandSchema(schema, []string{"#/definitions/truck"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/truck"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Ref.String())
 	assert.Equal(t, spec.Definitions["car"], schema)
 
 	sch := new(Schema)
-	_, err = expandSchema(*sch, []string{""}, resolver)
+	_, err = expandSchema(*sch, []string{""}, resolver, basePath)
 	assert.NoError(t, err)
 
 	schema = spec.Definitions["batch"]
-	s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Items.Schema.Ref.String())
 	assert.Equal(t, *schema.Items.Schema, spec.Definitions["brand"])
 
 	schema = spec.Definitions["batch2"]
-	s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Items.Schemas[0].Ref.String())
@@ -433,7 +531,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, schema.Items.Schemas[1], spec.Definitions["tag"])
 
 	schema = spec.Definitions["allofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AllOf[0].Ref.String())
@@ -442,7 +540,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, schema.AllOf[1], spec.Definitions["tag"])
 
 	schema = spec.Definitions["anyofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AnyOf[0].Ref.String())
@@ -451,7 +549,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, schema.AnyOf[1], spec.Definitions["tag"])
 
 	schema = spec.Definitions["oneofBoth"]
-	s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.OneOf[0].Ref.String())
@@ -460,28 +558,28 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, schema.OneOf[1], spec.Definitions["tag"])
 
 	schema = spec.Definitions["notSomething"]
-	s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.Not.Ref.String())
 	assert.Equal(t, *schema.Not, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withAdditional"]
-	s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AdditionalProperties.Schema.Ref.String())
 	assert.Equal(t, *schema.AdditionalProperties.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withAdditionalItems"]
-	s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	assert.Empty(t, schema.AdditionalItems.Schema.Ref.String())
 	assert.Equal(t, *schema.AdditionalItems.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["withPattern"]
-	s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop := schema.PatternProperties["^x-ab"]
@@ -489,7 +587,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, prop, spec.Definitions["tag"])
 
 	schema = spec.Definitions["deps"]
-	s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop2 := schema.Dependencies["something"]
@@ -497,7 +595,7 @@ func TestSchemaExpansion(t *testing.T) {
 	assert.Equal(t, *prop2.Schema, spec.Definitions["tag"])
 
 	schema = spec.Definitions["defined"]
-	s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver)
+	s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver, basePath)
 	schema = *s
 	assert.NoError(t, err)
 	prop = schema.Definitions["something"]
@@ -598,27 +696,29 @@ func resolutionContextServer() *httptest.Server {
 }
 
 func TestResolveRemoteRef_RootSame(t *testing.T) {
-	specs := "fixtures/specs"
+	specs := "fixtures/specs/"
 	fileserver := http.FileServer(http.Dir(specs))
 	server := httptest.NewServer(fileserver)
 	defer server.Close()
 
 	rootDoc := new(Swagger)
 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+	// the filename doesn't matter because ref will eventually point to refed.json
+	specBase, _ := absPath("fixtures/specs/anyotherfile.json")
 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
 		var result_0 Swagger
 		ref_0, _ := NewRef(server.URL + "/refed.json#")
-		resolver_0, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-		if assert.NoError(t, resolver_0.Resolve(&ref_0, &result_0)) {
+		resolver_0, _ := defaultSchemaLoader(rootDoc, nil, nil)
+		if assert.NoError(t, resolver_0.Resolve(&ref_0, &result_0, "")) {
 			assertSpecs(t, result_0, *rootDoc)
 		}
 
 		var result_1 Swagger
 		ref_1, _ := NewRef("./refed.json")
-		resolver_1, _ := defaultSchemaLoader(rootDoc, nil, &ExpandOptions{
-			RelativeBase: (specs),
+		resolver_1, _ := defaultSchemaLoader(rootDoc, &ExpandOptions{
+			RelativeBase: specBase,
 		}, nil)
-		if assert.NoError(t, resolver_1.Resolve(&ref_1, &result_1)) {
+		if assert.NoError(t, resolver_1.Resolve(&ref_1, &result_1, specBase)) {
 			assertSpecs(t, result_1, *rootDoc)
 		}
 	}
@@ -632,12 +732,13 @@ func TestResolveRemoteRef_FromFragment(t *testing.T) {
 
 	rootDoc := new(Swagger)
 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+
 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
 		var tgt Schema
 		ref, err := NewRef(server.URL + "/refed.json#/definitions/pet")
 		if assert.NoError(t, err) {
 			resolver := &schemaLoader{root: rootDoc, cache: initResolutionCache(), loadDoc: jsonDoc}
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, "")) {
 				assert.Equal(t, []string{"id", "name"}, tgt.Required)
 			}
 		}
@@ -656,8 +757,8 @@ func TestResolveRemoteRef_FromInvalidFragment(t *testing.T) {
 		var tgt Schema
 		ref, err := NewRef(server.URL + "/refed.json#/definitions/NotThere")
 		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			assert.Error(t, resolver.Resolve(&ref, &tgt))
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			assert.Error(t, resolver.Resolve(&ref, &tgt, ""))
 		}
 	}
 }
@@ -666,56 +767,78 @@ func TestResolveRemoteRef_WithResolutionContext(t *testing.T) {
 	server := resolutionContextServer()
 	defer server.Close()
 
-	rootDoc := new(Swagger)
-	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
-	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
-		var tgt Schema
-		ref, err := NewRef(server.URL + "/resolution.json#/definitions/bool")
-		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
-				assert.Equal(t, StringOrArray([]string{"boolean"}), tgt.Type)
-			}
-		}
+	var tgt Schema
+	ref, err := NewRef(server.URL + "/resolution.json#/definitions/bool")
+	if assert.NoError(t, err) {
+		tgt.Ref = ref
+		ExpandSchema(&tgt, nil, nil)
+		assert.Equal(t, StringOrArray([]string{"boolean"}), tgt.Type)
 	}
+
 }
 
 func TestResolveRemoteRef_WithNestedResolutionContext(t *testing.T) {
 	server := resolutionContextServer()
 	defer server.Close()
 
-	rootDoc := new(Swagger)
-	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
-	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
-		var tgt Schema
-		ref, err := NewRef(server.URL + "/resolution.json#/items/items")
-		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
-				assert.Equal(t, StringOrArray([]string{"string"}), tgt.Type)
-			}
-		}
+	var tgt Schema
+	ref, err := NewRef(server.URL + "/resolution.json#/items")
+	if assert.NoError(t, err) {
+		tgt.Ref = ref
+		ExpandSchema(&tgt, nil, nil)
+		assert.Equal(t, StringOrArray([]string{"string"}), tgt.Items.Schema.Type)
 	}
 }
 
+/* This next test will have to wait until we do full $ID analysis for every subschema on every file that is referenced */
+/* For now, TestResolveRemoteRef_WithNestedResolutionContext replaces this next test */
+// func TestResolveRemoteRef_WithNestedResolutionContext_WithParentID(t *testing.T) {
+// 	server := resolutionContextServer()
+// 	defer server.Close()
+
+// 	var tgt Schema
+// 	ref, err := NewRef(server.URL + "/resolution.json#/items/items")
+// 	if assert.NoError(t, err) {
+// 		tgt.Ref = ref
+// 		ExpandSchema(&tgt, nil, nil)
+// 		assert.Equal(t, StringOrArray([]string{"string"}), tgt.Type)
+// 	}
+// }
+
 func TestResolveRemoteRef_WithNestedResolutionContextWithFragment(t *testing.T) {
 	server := resolutionContextServer()
 	defer server.Close()
 
-	rootDoc := new(Swagger)
-	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
-	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
-		var tgt Schema
-		ref, err := NewRef(server.URL + "/resolution2.json#/items/items")
-		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
-				assert.Equal(t, StringOrArray([]string{"file"}), tgt.Type)
-			}
-		}
+	var tgt Schema
+	ref, err := NewRef(server.URL + "/resolution2.json#/items")
+	if assert.NoError(t, err) {
+		tgt.Ref = ref
+		ExpandSchema(&tgt, nil, nil)
+		assert.Equal(t, StringOrArray([]string{"file"}), tgt.Items.Schema.Type)
 	}
+
 }
 
+/* This next test will have to wait until we do full $ID analysis for every subschema on every file that is referenced */
+/* For now, TestResolveRemoteRef_WithNestedResolutionContext replaces this next test */
+// func TestResolveRemoteRef_WithNestedResolutionContextWithFragment_WithParentID(t *testing.T) {
+// 	server := resolutionContextServer()
+// 	defer server.Close()
+
+// 	rootDoc := new(Swagger)
+// 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+// 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
+// 		var tgt Schema
+// 		ref, err := NewRef(server.URL + "/resolution2.json#/items/items")
+// 		if assert.NoError(t, err) {
+// 			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+// 			if assert.NoError(t, resolver.Resolve(&ref, &tgt, "")) {
+// 				assert.Equal(t, StringOrArray([]string{"file"}), tgt.Type)
+// 			}
+// 		}
+// 	}
+// }
+
 func TestResolveRemoteRef_ToParameter(t *testing.T) {
 	specs := "fixtures/specs"
 	fileserver := http.FileServer(http.Dir(specs))
@@ -729,8 +852,8 @@ func TestResolveRemoteRef_ToParameter(t *testing.T) {
 		ref, err := NewRef(server.URL + "/refed.json#/parameters/idParam")
 		if assert.NoError(t, err) {
 
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, "")) {
 				assert.Equal(t, "id", tgt.Name)
 				assert.Equal(t, "path", tgt.In)
 				assert.Equal(t, "ID of pet to fetch", tgt.Description)
@@ -755,8 +878,8 @@ func TestResolveRemoteRef_ToPathItem(t *testing.T) {
 		ref, err := NewRef(server.URL + "/refed.json#/paths/" + jsonpointer.Escape("/pets/{id}"))
 		if assert.NoError(t, err) {
 
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, "")) {
 				assert.Equal(t, rootDoc.Paths.Paths["/pets/{id}"].Get, tgt.Get)
 			}
 		}
@@ -776,8 +899,8 @@ func TestResolveRemoteRef_ToResponse(t *testing.T) {
 		ref, err := NewRef(server.URL + "/refed.json#/responses/petResponse")
 		if assert.NoError(t, err) {
 
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, "")) {
 				assert.Equal(t, rootDoc.Responses["petResponse"], tgt)
 			}
 		}
@@ -790,8 +913,8 @@ func TestResolveLocalRef_SameRoot(t *testing.T) {
 
 	result := new(Swagger)
 	ref, _ := NewRef("#")
-	resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-	err := resolver.Resolve(&ref, result)
+	resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+	err := resolver.Resolve(&ref, result, "")
 	if assert.NoError(t, err) {
 		assert.Equal(t, rootDoc, result)
 	}
@@ -804,8 +927,8 @@ func TestResolveLocalRef_FromFragment(t *testing.T) {
 	var tgt Schema
 	ref, err := NewRef("#/definitions/Category")
 	if assert.NoError(t, err) {
-		resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-		err := resolver.Resolve(&ref, &tgt)
+		resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+		err := resolver.Resolve(&ref, &tgt, "")
 		if assert.NoError(t, err) {
 			assert.Equal(t, "Category", tgt.ID)
 		}
@@ -819,8 +942,8 @@ func TestResolveLocalRef_FromInvalidFragment(t *testing.T) {
 	var tgt Schema
 	ref, err := NewRef("#/definitions/NotThere")
 	if assert.NoError(t, err) {
-		resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-		err := resolver.Resolve(&ref, &tgt)
+		resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+		err := resolver.Resolve(&ref, &tgt, "")
 		assert.Error(t, err)
 	}
 }
@@ -828,12 +951,13 @@ func TestResolveLocalRef_FromInvalidFragment(t *testing.T) {
 func TestResolveLocalRef_Parameter(t *testing.T) {
 	rootDoc := new(Swagger)
 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+	basePath, _ := absPath("fixtures/specs/refed.json")
 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
 		var tgt Parameter
 		ref, err := NewRef("#/parameters/idParam")
 		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) {
 				assert.Equal(t, "id", tgt.Name)
 				assert.Equal(t, "path", tgt.In)
 				assert.Equal(t, "ID of pet to fetch", tgt.Description)
@@ -848,12 +972,13 @@ func TestResolveLocalRef_Parameter(t *testing.T) {
 func TestResolveLocalRef_PathItem(t *testing.T) {
 	rootDoc := new(Swagger)
 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+	basePath, _ := absPath("fixtures/specs/refed.json")
 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
 		var tgt PathItem
 		ref, err := NewRef("#/paths/" + jsonpointer.Escape("/pets/{id}"))
 		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) {
 				assert.Equal(t, rootDoc.Paths.Paths["/pets/{id}"].Get, tgt.Get)
 			}
 		}
@@ -863,12 +988,13 @@ func TestResolveLocalRef_PathItem(t *testing.T) {
 func TestResolveLocalRef_Response(t *testing.T) {
 	rootDoc := new(Swagger)
 	b, err := ioutil.ReadFile("fixtures/specs/refed.json")
+	basePath, _ := absPath("fixtures/specs/refed.json")
 	if assert.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) {
 		var tgt Response
 		ref, err := NewRef("#/responses/petResponse")
 		if assert.NoError(t, err) {
-			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil, nil)
-			if assert.NoError(t, resolver.Resolve(&ref, &tgt)) {
+			resolver, _ := defaultSchemaLoader(rootDoc, nil, nil)
+			if assert.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) {
 				assert.Equal(t, rootDoc.Responses["petResponse"], tgt)
 			}
 		}