more coverage + more endpoints implemented, up to 65.7% coverage now

Author: CpuID

app.go

@@ -10,6 +10,7 @@ import (
 // App encapsulates all of the parameters necessary for starting up
 // an aws mock metadata server. These can either be set via command line or directly.
 type App struct {
+	AmiID                 string
 	AvailabilityZone      string
 	AppPort               string
 	Hostname              string
@@ -36,14 +37,15 @@ func main() {
 }
 
 func (app *App) addFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&app.AvailabilityZone, "availability-zone", app.AvailabilityZone, "Availability zone")
-	fs.StringVar(&app.AppPort, "app-port", app.AppPort, "Http port")
-	fs.StringVar(&app.Hostname, "hostname", app.Hostname, "ec2 instance hostname")
-	fs.StringVar(&app.InstanceID, "instance-id", app.InstanceID, "ec2 instance id")
-	fs.StringVar(&app.PrivateIp, "private-ip", app.PrivateIp, "Private ip")
-	fs.StringVar(&app.RoleArn, "role-arn", app.RoleArn, "IAM role Arn")
-	fs.StringVar(&app.RoleName, "role-name", app.RoleName, "IAM role name")
+	fs.StringVar(&app.AmiID, "ami-id", app.AmiID, "EC2 Instance AMI ID")
+	fs.StringVar(&app.AvailabilityZone, "availability-zone", app.AvailabilityZone, "Availability Zone")
+	fs.StringVar(&app.AppPort, "app-port", app.AppPort, "HTTP Port")
+	fs.StringVar(&app.Hostname, "hostname", app.Hostname, "EC2 Instance Hostname")
+	fs.StringVar(&app.InstanceID, "instance-id", app.InstanceID, "EC2 instance id")
+	fs.StringVar(&app.PrivateIp, "private-ip", app.PrivateIp, "Private IP")
+	fs.StringVar(&app.RoleArn, "role-arn", app.RoleArn, "IAM Role ARN")
+	fs.StringVar(&app.RoleName, "role-name", app.RoleName, "IAM Role Name")
 	fs.BoolVar(&app.Verbose, "verbose", false, "Verbose")
-	fs.StringVar(&app.VpcID, "vpc-id", app.VpcID, "VPC id")
+	fs.StringVar(&app.VpcID, "vpc-id", app.VpcID, "VPC ID")
 	fs.BoolVar(&app.NoSchemeHostRedirects, "no-scheme-host-redirects", app.NoSchemeHostRedirects, "Disable the scheme://host prefix in Location redirect headers")
 }

main_test.go

@@ -15,6 +15,7 @@ func TestMain(m *testing.M) {
 	// Setup the test API
 	app := &App{}
 	// Mock parameters
+	app.AmiID = "ami-asdfasdf"
 	app.AvailabilityZone = "us-east-1a"
 	// AppPort not required
 	app.Hostname = "testhostname"

server.go

@@ -73,16 +73,38 @@ func (app *App) versionSubRouter(sr *mux.Router, version string) {
 	ii.Handle("", appHandler(app.trailingSlashRedirect))
 	ii.Handle("/", appHandler(app.instanceIdentityHandler))
 	ii.Handle("/document", appHandler(app.instanceIdentityDocumentHandler))
-	// TODO: implement
-	//ii.Handle("/pkcs7", appHandler(app.instanceIdentityHandler))
-	//ii.Handle("/signature", appHandler(app.instanceIdentityHandler))
+	ii.Handle("/document/", appHandler(app.instanceIdentityDocumentHandler))
+	ii.Handle("/pkcs7", appHandler(app.instanceIdentityPkcs7Handler))
+	ii.Handle("/pkcs7/", appHandler(app.instanceIdentityPkcs7Handler))
+	ii.Handle("/signature", appHandler(app.instanceIdentitySignatureHandler))
+	ii.Handle("/signature/", appHandler(app.instanceIdentitySignatureHandler))
 
 	m := sr.PathPrefix("/meta-data").Subrouter()
 	m.Handle("", appHandler(app.trailingSlashRedirect))
 	m.Handle("/", appHandler(app.metaDataHandler))
+	m.Handle("/ami-id", appHandler(app.amiIdHandler))
+	m.Handle("/ami-id/", appHandler(app.amiIdHandler))
+	m.Handle("/ami-launch-index", appHandler(app.amiLaunchIndexHandler))
+	m.Handle("/ami-launch-index/", appHandler(app.amiLaunchIndexHandler))
+	m.Handle("/ami-manifest-path", appHandler(app.amiManifestPathHandler))
+	m.Handle("/ami-manifest-path/", appHandler(app.amiManifestPathHandler))
+
+	bdm := m.PathPrefix("/block-device-mapping").Subrouter()
+	bdm.Handle("", appHandler(app.trailingSlashRedirect))
+	bdm.Handle("/", appHandler(app.blockDeviceMappingHandler))
+	bdm.Handle("/ami", appHandler(app.blockDeviceMappingAmiHandler))
+	bdm.Handle("/ami/", appHandler(app.blockDeviceMappingAmiHandler))
+	bdm.Handle("/root", appHandler(app.blockDeviceMappingRootHandler))
+	bdm.Handle("/root/", appHandler(app.blockDeviceMappingRootHandler))
+
+	m.Handle("/hostname", appHandler(app.hostnameHandler))
+	m.Handle("/hostname/", appHandler(app.hostnameHandler))
 	m.Handle("/instance-id", appHandler(app.instanceIDHandler))
+	m.Handle("/instance-id/", appHandler(app.instanceIDHandler))
 	m.Handle("/local-hostname", appHandler(app.localHostnameHandler))
+	m.Handle("/local-hostname/", appHandler(app.localHostnameHandler))
 	m.Handle("/local-ipv4", appHandler(app.privateIpHandler))
+	m.Handle("/local-ipv4/", appHandler(app.privateIpHandler))
 
 	p := m.PathPrefix("/placement").Subrouter()
 	p.Handle("/availability-zone", appHandler(app.availabilityZoneHandler))
@@ -100,6 +122,7 @@ func (app *App) versionSubRouter(sr *mux.Router, version string) {
 	d.Handle("/{path:.*}", appHandler(app.notFoundHandler))
 	ii.Handle("/{path:.*}", appHandler(app.notFoundHandler))
 	m.Handle("/{path:.*}", appHandler(app.notFoundHandler))
+	bdm.Handle("/{path:.*}", appHandler(app.notFoundHandler))
 	p.Handle("/{path:.*}", appHandler(app.notFoundHandler))
 	i.Handle("/{path:.*}", appHandler(app.notFoundHandler))
 	n.Handle("/{path:.*}", appHandler(app.notFoundHandler))
@@ -135,6 +158,7 @@ signature
 `)
 }
 
+// NOTE: order of keys here differs from real metadata service, in theory most (proper) JSON parsers should be fine with it though...
 type InstanceIdentityDocument struct {
 	AvailabilityZone   string  `json:"availabilityZone"`
 	Region             string  `json:"region"`
@@ -157,13 +181,13 @@ func (app *App) instanceIdentityDocumentHandler(w http.ResponseWriter, r *http.R
 		AvailabilityZone:   app.AvailabilityZone,
 		Region:             app.AvailabilityZone[:len(app.AvailabilityZone)-1],
 		DevpayProductCodes: nil,
-		PrivateIp:          "127.0.0.1",
+		PrivateIp:          app.PrivateIp,
 		Version:            "2010-08-31",
-		InstanceId:         "i-wxyz1234",
+		InstanceId:         app.InstanceID,
 		BillingProducts:    nil,
 		InstanceType:       "t2.micro",
 		AccountId:          "1234567890",
-		ImageId:            "ami-123456",
+		ImageId:            app.AmiID,
 		PendingTime:        "2016-04-15T12:14:15Z",
 		Architecture:       "x86_64",
 		KernelId:           nil,
@@ -175,7 +199,20 @@ func (app *App) instanceIdentityDocumentHandler(w http.ResponseWriter, r *http.R
 	}
 }
 
+func (app *App) instanceIdentityPkcs7Handler(w http.ResponseWriter, r *http.Request) {
+	// TODO: adjust output to suit
+	write(w, `
+`)
+}
+
+func (app *App) instanceIdentitySignatureHandler(w http.ResponseWriter, r *http.Request) {
+	// TODO: adjust output to suit
+	write(w, `
+`)
+}
+
 func (app *App) metaDataHandler(w http.ResponseWriter, r *http.Request) {
+	// TODO: if IAM Role/Instance Profile is disabled, don't add iam/ to the list (same behavior as real metadata service)
 	write(w, `ami-id
 ami-launch-index
 ami-manifest-path
@@ -199,6 +236,36 @@ security-groups
 services/`)
 }
 
+func (app *App) amiIdHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, app.AmiID)
+}
+
+func (app *App) amiLaunchIndexHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, "0")
+}
+
+func (app *App) amiManifestPathHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, "(unknown)")
+}
+
+func (app *App) blockDeviceMappingHandler(w http.ResponseWriter, r *http.Request) {
+	// Not exposing any extra volumes for now, this is pretty standard for an EBS backed EC2 instance.
+	write(w, `ami
+root`)
+}
+
+func (app *App) blockDeviceMappingAmiHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, "/dev/xvda")
+}
+
+func (app *App) blockDeviceMappingRootHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, "/dev/xvda")
+}
+
+func (app *App) hostnameHandler(w http.ResponseWriter, r *http.Request) {
+	write(w, app.Hostname)
+}
+
 func (app *App) instanceIDHandler(w http.ResponseWriter, r *http.Request) {
 	write(w, app.InstanceID)
 }

server_test.go

@@ -105,6 +105,42 @@ signature
 	doBodyTest(t, "/latest/dynamic/instance-identity/", expected_body)
 }
 
+func TestLatestDynamicInstanceIdentityDocument(t *testing.T) {
+	expected_body := `{
+  "instanceId" : "i-asdfasdf",
+  "billingProducts" : null,
+  "imageId" : "ami-asdfasdf",
+  "architecture" : "x86_64",
+  "pendingTime" : "",
+  "instanceType" : "t2.micro",
+  "accountId" : "",
+  "kernelId" : null,
+  "ramdiskId" : null,
+  "region" : "us-east-1",
+  "version" : "2010-08-31",
+  "availabilityZone" : "us-east-1a",
+  "devpayProductCodes" : null,
+  "privateIp" : "10.20.30.40"
+}`
+
+	doBodyTest(t, "/latest/dynamic/instance-identity/document", expected_body)
+	doBodyTest(t, "/latest/dynamic/instance-identity/document/", expected_body)
+}
+
+func TestLatestDynamicInstanceIdentityPkcs7(t *testing.T) {
+	expected_body := `TODO-correct-output`
+
+	doBodyTest(t, "/latest/dynamic/instance-identity/pkcs7", expected_body)
+	doBodyTest(t, "/latest/dynamic/instance-identity/pkcs7/", expected_body)
+}
+
+func TestLatestDynamicInstanceIdentitySignature(t *testing.T) {
+	expected_body := `TODO-correct-output`
+
+	doBodyTest(t, "/latest/dynamic/instance-identity/signature", expected_body)
+	doBodyTest(t, "/latest/dynamic/instance-identity/signature/", expected_body)
+}
+
 func TestLatestMetaData(t *testing.T) {
 	// NOTE: iam/ only appears if there is an IAM Instance Profile attached to the instance. assuming available for simulation purposes for now.
 	expected_body := `ami-id
@@ -133,6 +169,56 @@ services/`
 	doBodyTest(t, "/latest/meta-data/", expected_body)
 }
 
+func TestLatestMetaDataAmiId(t *testing.T) {
+	expected_body := `ami-asdfasdf`
+
+	doBodyTest(t, "/latest/meta-data/ami-id", expected_body)
+	doBodyTest(t, "/latest/meta-data/ami-id/", expected_body)
+}
+
+func TestLatestMetaDataAmiLaunchIndex(t *testing.T) {
+	expected_body := `0`
+
+	doBodyTest(t, "/latest/meta-data/ami-launch-index", expected_body)
+	doBodyTest(t, "/latest/meta-data/ami-launch-index/", expected_body)
+}
+
+func TestLatestMetaDataAmiManifestPath(t *testing.T) {
+	expected_body := `(unknown)`
+
+	doBodyTest(t, "/latest/meta-data/ami-manifest-path", expected_body)
+	doBodyTest(t, "/latest/meta-data/ami-manifest-path/", expected_body)
+}
+
+func TestLatestMetaDataBlockDeviceMapping(t *testing.T) {
+	expected_body := `ami
+root`
+
+	doRedirectTest(t, "/latest/meta-data/block-device-mapping", "/latest/meta-data/block-device-mapping/")
+	doBodyTest(t, "/latest/meta-data/block-device-mapping/", expected_body)
+}
+
+func TestLatestMetaDataBlockDeviceMappingAmi(t *testing.T) {
+	expected_body := `/dev/xvda`
+
+	doBodyTest(t, "/latest/meta-data/block-device-mapping/ami", expected_body)
+	doBodyTest(t, "/latest/meta-data/block-device-mapping/ami/", expected_body)
+}
+
+func TestLatestMetaDataBlockDeviceMappingRoot(t *testing.T) {
+	expected_body := `/dev/xvda`
+
+	doBodyTest(t, "/latest/meta-data/block-device-mapping/root", expected_body)
+	doBodyTest(t, "/latest/meta-data/block-device-mapping/root/", expected_body)
+}
+
+func TestLatestMetaDataHostname(t *testing.T) {
+	expected_body := `testhostname`
+
+	doBodyTest(t, "/latest/meta-data/hostname", expected_body)
+	doBodyTest(t, "/latest/meta-data/hostname/", expected_body)
+}
+
 func TestLatestUserData(t *testing.T) {
 	// TODO: /latest/user-data returns a 404 if none exists... or if one exists, will return it?
 	// should we expose this in the API? not implemented right now. could be useful...