diff --git a/action/get.go b/action/get.go
index 5d4e143..d3ef2ef 100644
--- a/action/get.go
+++ b/action/get.go
@@ -43,7 +43,7 @@
 	// Fetch the new packages. Can't resolve versions via installer.Update if
 	// get is called while the vendor/ directory is empty so we checkout
 	// everything.
-	err = installer.Checkout(conf, false)
+	err = installer.Checkout(conf)
 	if err != nil {
 		msg.Die("Failed to checkout packages: %s", err)
 	}
@@ -68,7 +68,7 @@
 	}
 
 	// Set Reference
-	if err := repo.SetReference(confcopy); err != nil {
+	if err := repo.SetReference(confcopy, installer.ResolveTest); err != nil {
 		msg.Err("Failed to set references: %s", err)
 	}
 
@@ -112,7 +112,7 @@
 	if err != nil {
 		msg.Die("Failed to generate config hash. Unable to generate lock file.")
 	}
-	lock := cfg.NewLockfile(confcopy.Imports, hash)
+	lock := cfg.NewLockfile(confcopy.Imports, confcopy.DevImports, hash)
 	if err := lock.WriteFile(filepath.Join(base, gpath.LockFile)); err != nil {
 		msg.Die("Failed to write glide lock file: %s", err)
 	}
diff --git a/action/install.go b/action/install.go
index 25a5f08..3deb9d2 100644
--- a/action/install.go
+++ b/action/install.go
@@ -53,7 +53,7 @@
 	msg.Info("Setting references.")
 
 	// Set reference
-	if err := repo.SetReference(newConf); err != nil {
+	if err := repo.SetReference(newConf, installer.ResolveTest); err != nil {
 		msg.Err("Failed to set references: %s (Skip to cleanup)", err)
 	}
 
diff --git a/action/remove.go b/action/remove.go
index bdf831b..fc305f5 100644
--- a/action/remove.go
+++ b/action/remove.go
@@ -27,7 +27,7 @@
 
 	confcopy.Imports = inst.List(confcopy)
 
-	if err := repo.SetReference(confcopy); err != nil {
+	if err := repo.SetReference(confcopy, inst.ResolveTest); err != nil {
 		msg.Err("Failed to set references: %s", err)
 	}
 
diff --git a/action/update.go b/action/update.go
index 23d3f4f..cb33e63 100644
--- a/action/update.go
+++ b/action/update.go
@@ -30,13 +30,13 @@
 	}
 
 	// Try to check out the initial dependencies.
-	if err := installer.Checkout(conf, false); err != nil {
+	if err := installer.Checkout(conf); err != nil {
 		msg.Die("Failed to do initial checkout of config: %s", err)
 	}
 
 	// Set the versions for the initial dependencies so that resolved dependencies
 	// are rooted in the correct version of the base.
-	if err := repo.SetReference(conf); err != nil {
+	if err := repo.SetReference(conf, installer.ResolveTest); err != nil {
 		msg.Die("Failed to set initial config references: %s", err)
 	}
 
@@ -51,15 +51,11 @@
 			msg.Die("Could not update packages: %s", err)
 		}
 
-		// TODO: There is no support here for importing Godeps, GPM, and GB files.
-		// I think that all we really need to do now is hunt for these files, and then
-		// roll their version numbers into the config file.
-
 		// Set references. There may be no remaining references to set since the
 		// installer set them as it went to make sure it parsed the right imports
 		// from the right version of the package.
 		msg.Info("Setting references for remaining imports")
-		if err := repo.SetReference(confcopy); err != nil {
+		if err := repo.SetReference(confcopy, installer.ResolveTest); err != nil {
 			msg.Err("Failed to set references: %s (Skip to cleanup)", err)
 		}
 	}
@@ -90,7 +86,7 @@
 		if err != nil {
 			msg.Die("Failed to generate config hash. Unable to generate lock file.")
 		}
-		lock := cfg.NewLockfile(confcopy.Imports, hash)
+		lock := cfg.NewLockfile(confcopy.Imports, confcopy.DevImports, hash)
 		wl := true
 		if gpath.HasLock(base) {
 			yml, err := ioutil.ReadFile(filepath.Join(base, gpath.LockFile))
diff --git a/cfg/lock.go b/cfg/lock.go
index 8b4d252..2b2c4c8 100644
--- a/cfg/lock.go
+++ b/cfg/lock.go
@@ -131,11 +131,12 @@
 }
 
 // NewLockfile is used to create an instance of Lockfile.
-func NewLockfile(ds Dependencies, hash string) *Lockfile {
+func NewLockfile(ds, tds Dependencies, hash string) *Lockfile {
 	lf := &Lockfile{
-		Hash:    hash,
-		Updated: time.Now(),
-		Imports: make([]*Lock, len(ds)),
+		Hash:       hash,
+		Updated:    time.Now(),
+		Imports:    make([]*Lock, len(ds)),
+		DevImports: make([]*Lock, len(tds)),
 	}
 
 	for i := 0; i < len(ds); i++ {
@@ -152,6 +153,20 @@
 
 	sort.Sort(lf.Imports)
 
+	for i := 0; i < len(tds); i++ {
+		lf.DevImports[i] = &Lock{
+			Name:        tds[i].Name,
+			Version:     tds[i].Pin,
+			Repository:  tds[i].Repository,
+			VcsType:     tds[i].VcsType,
+			Subpackages: tds[i].Subpackages,
+			Arch:        tds[i].Arch,
+			Os:          tds[i].Os,
+		}
+	}
+
+	sort.Sort(lf.DevImports)
+
 	return lf
 }
 
diff --git a/dependency/resolver.go b/dependency/resolver.go
index 4d9d34d..3b4e1df 100644
--- a/dependency/resolver.go
+++ b/dependency/resolver.go
@@ -31,7 +31,7 @@
 	// When it returns false with no error, this indicates that the handler did
 	// its job, but the resolver should not do any additional work on the
 	// package.
-	NotFound(pkg string) (bool, error)
+	NotFound(pkg string, addTest bool) (bool, error)
 
 	// OnGopath is called when the Resolver finds a dependency, but it's only on GOPATH.
 	//
@@ -45,12 +45,12 @@
 	//
 	// An error indicates that OnGopath cannot complete its intended operation.
 	// Not all false results are errors.
-	OnGopath(pkg string) (bool, error)
+	OnGopath(pkg string, addTest bool) (bool, error)
 
 	// InVendor is called when the Resolver finds a dependency in the vendor/ directory.
 	//
 	// This can be used update a project found in the vendor/ folder.
-	InVendor(pkg string) error
+	InVendor(pkg string, addTest bool) error
 }
 
 // DefaultMissingPackageHandler is the default handler for missing packages.
@@ -65,21 +65,21 @@
 // NotFound prints a warning and then stores the package name in Missing.
 //
 // It never returns an error, and it always returns false.
-func (d *DefaultMissingPackageHandler) NotFound(pkg string) (bool, error) {
+func (d *DefaultMissingPackageHandler) NotFound(pkg string, addTest bool) (bool, error) {
 	msg.Warn("Package %s is not installed", pkg)
 	d.Missing = append(d.Missing, pkg)
 	return false, nil
 }
 
 // OnGopath is run when a package is missing from vendor/ but found in the GOPATH
-func (d *DefaultMissingPackageHandler) OnGopath(pkg string) (bool, error) {
+func (d *DefaultMissingPackageHandler) OnGopath(pkg string, addTest bool) (bool, error) {
 	msg.Warn("Package %s is only on GOPATH.", pkg)
 	d.Gopath = append(d.Gopath, pkg)
 	return false, nil
 }
 
 // InVendor is run when a package is found in the vendor/ folder
-func (d *DefaultMissingPackageHandler) InVendor(pkg string) error {
+func (d *DefaultMissingPackageHandler) InVendor(pkg string, addTest bool) error {
 	msg.Info("Package %s found in vendor/ folder", pkg)
 	return nil
 }
@@ -143,8 +143,7 @@
 	ResolveTest bool
 
 	// Items already in the queue.
-	alreadyQ  map[string]bool
-	talreadyQ map[string]bool
+	alreadyQ map[string]bool
 
 	// Attempts to scan that had unrecoverable error.
 	hadError map[string]bool
@@ -226,7 +225,7 @@
 	if r.ResolveAllFiles {
 		return r.resolveList(l, false)
 	}
-	return r.resolveImports(l, false)
+	return r.resolveImports(l, false, false)
 }
 
 // dirHasPrefix tests whether the directory dir begins with prefix.
@@ -362,11 +361,11 @@
 			tre, err := r.resolveList(l, false)
 			return re, tre, err
 		}
-		re, err := r.resolveImports(l, false)
+		re, err := r.resolveImports(l, false, false)
 		if err != nil {
 			return []string{}, []string{}, err
 		}
-		tre, err := r.resolveImports(tl, true)
+		tre, err := r.resolveImports(tl, true, true)
 		return re, tre, err
 	}
 
@@ -398,31 +397,18 @@
 //
 // If one of the passed in packages does not exist in the vendor directory,
 // an error is returned.
-func (r *Resolver) ResolveAll(deps []*cfg.Dependency) ([]string, error) {
-	var queue *list.List
-	if r.ResolveAllFiles {
-		queue = sliceToQueue(deps, r.VendorDir)
-	} else {
-		queue = list.New()
-	}
+func (r *Resolver) ResolveAll(deps []*cfg.Dependency, addTest bool) ([]string, error) {
 
-	loc, _, err := r.ResolveLocal(false)
-	if err != nil {
-		return []string{}, err
-	}
-	for _, l := range loc {
-		msg.Debug("Adding local Import %s to queue", l)
-		queue.PushBack(l)
-	}
+	queue := sliceToQueue(deps, r.VendorDir)
 
 	if r.ResolveAllFiles {
 		return r.resolveList(queue, false)
 	}
-	return r.resolveImports(queue, false)
+	return r.resolveImports(queue, false, addTest)
 }
 
-// stripv strips the vendor/ prefix from vendored packages.
-func (r *Resolver) stripv(str string) string {
+// Stripv strips the vendor/ prefix from vendored packages.
+func (r *Resolver) Stripv(str string) string {
 	return strings.TrimPrefix(str, r.VendorDir+string(os.PathSeparator))
 }
 
@@ -443,31 +429,27 @@
 //
 // The resolver's handler is used in the cases where a package cannot be
 // located.
-func (r *Resolver) resolveImports(queue *list.List, testDeps bool) ([]string, error) {
+//
+// testDeps specifies if the test dependencies should be resolved and addTest
+// specifies if the dependencies should be added to the Config.DevImports. This
+// is important because we may resolve normal dependencies of test deps and add
+// them to the DevImports list.
+func (r *Resolver) resolveImports(queue *list.List, testDeps, addTest bool) ([]string, error) {
 	msg.Debug("Resolving import path")
-	if testDeps {
-		msg.Debug("Resolving test dependencies")
-	}
 
 	// When test deps passed in but not resolving return empty.
-	if testDeps && !r.ResolveTest {
+	if (testDeps || addTest) && !r.ResolveTest {
 		return []string{}, nil
 	}
 
 	for e := queue.Front(); e != nil; e = e.Next() {
 		vdep := e.Value.(string)
-		dep := r.stripv(vdep)
-
+		dep := r.Stripv(vdep)
 		// Check if marked in the Q and then explicitly mark it. We want to know
 		// if it had previously been marked and ensure it for the future.
-		var foundQ bool
-		if testDeps {
-			_, foundQ = r.talreadyQ[dep]
-			r.talreadyQ[dep] = true
-		} else {
-			_, foundQ = r.alreadyQ[dep]
-			r.alreadyQ[dep] = true
-		}
+
+		_, foundQ := r.alreadyQ[dep]
+		r.alreadyQ[dep] = true
 
 		// If we've already encountered an error processing this dependency
 		// skip it.
@@ -516,17 +498,13 @@
 				// not to get stuck in a recursion.
 
 				// If the location doesn't exist try to fetch it.
-				if ok, err2 := r.Handler.NotFound(dep); ok {
-					if testDeps {
-						r.talreadyQ[dep] = true
-					} else {
-						r.alreadyQ[dep] = true
-					}
+				if ok, err2 := r.Handler.NotFound(dep, addTest); ok {
+					r.alreadyQ[dep] = true
 
 					// By adding to the queue it will get reprocessed now that
 					// it exists.
 					queue.PushBack(r.vpath(dep))
-					r.VersionHandler.SetVersion(dep, testDeps)
+					r.VersionHandler.SetVersion(dep, addTest)
 				} else if err2 != nil {
 					r.hadError[dep] = true
 					msg.Err("Error looking for %s: %s", dep, err2)
@@ -566,28 +544,20 @@
 				msg.Debug("In vendor: %s", imp)
 				if _, ok := r.alreadyQ[imp]; !ok {
 					msg.Debug("Marking %s to be scanned.", imp)
-					if testDeps {
-						r.talreadyQ[dep] = true
-					} else {
-						r.alreadyQ[dep] = true
-					}
+					r.alreadyQ[dep] = true
 					queue.PushBack(r.vpath(imp))
-					if err := r.Handler.InVendor(imp); err == nil {
-						r.VersionHandler.SetVersion(imp, testDeps)
+					if err := r.Handler.InVendor(imp, addTest); err == nil {
+						r.VersionHandler.SetVersion(imp, addTest)
 					} else {
 						msg.Warn("Error updating %s: %s", imp, err)
 					}
 				}
 			case LocUnknown:
 				msg.Debug("Missing %s. Trying to resolve.", imp)
-				if ok, err := r.Handler.NotFound(imp); ok {
-					if testDeps {
-						r.talreadyQ[dep] = true
-					} else {
-						r.alreadyQ[dep] = true
-					}
+				if ok, err := r.Handler.NotFound(imp, addTest); ok {
+					r.alreadyQ[dep] = true
 					queue.PushBack(r.vpath(imp))
-					r.VersionHandler.SetVersion(imp, testDeps)
+					r.VersionHandler.SetVersion(imp, addTest)
 				} else if err != nil {
 					r.hadError[dep] = true
 					msg.Warn("Error looking for %s: %s", imp, err)
@@ -599,14 +569,10 @@
 				msg.Debug("Found on GOPATH, not vendor: %s", imp)
 				if _, ok := r.alreadyQ[imp]; !ok {
 					// Only scan it if it gets moved into vendor/
-					if ok, _ := r.Handler.OnGopath(imp); ok {
-						if testDeps {
-							r.talreadyQ[dep] = true
-						} else {
-							r.alreadyQ[dep] = true
-						}
+					if ok, _ := r.Handler.OnGopath(imp, addTest); ok {
+						r.alreadyQ[dep] = true
 						queue.PushBack(r.vpath(imp))
-						r.VersionHandler.SetVersion(imp, testDeps)
+						r.VersionHandler.SetVersion(imp, addTest)
 					}
 				}
 			}
@@ -619,7 +585,7 @@
 
 	// In addition to generating a list
 	for e := queue.Front(); e != nil; e = e.Next() {
-		t := r.stripv(e.Value.(string))
+		t := r.Stripv(e.Value.(string))
 		root, sp := util.NormalizeName(t)
 
 		// Skip ignored packages
@@ -630,6 +596,9 @@
 
 		// TODO(mattfarina): Need to eventually support devImport
 		existing := r.Config.Imports.Get(root)
+		if existing == nil && addTest {
+			existing = r.Config.DevImports.Get(root)
+		}
 		if existing != nil {
 			if sp != "" && !existing.HasSubpackage(sp) {
 				existing.Subpackages = append(existing.Subpackages, sp)
@@ -642,7 +611,11 @@
 				newDep.Subpackages = []string{sp}
 			}
 
-			r.Config.Imports = append(r.Config.Imports, newDep)
+			if addTest {
+				r.Config.DevImports = append(r.Config.DevImports, newDep)
+			} else {
+				r.Config.Imports = append(r.Config.Imports, newDep)
+			}
 		}
 		res = append(res, t)
 	}
@@ -831,7 +804,7 @@
 		switch info.Loc {
 		case LocUnknown:
 			// Do we resolve here?
-			found, err := r.Handler.NotFound(imp)
+			found, err := r.Handler.NotFound(imp, false)
 			if err != nil {
 				msg.Err("Failed to fetch %s: %s", imp, err)
 			}
@@ -844,13 +817,13 @@
 		case LocVendor:
 			//msg.Debug("Vendored: %s", imp)
 			buf = append(buf, info.Path)
-			if err := r.Handler.InVendor(imp); err == nil {
+			if err := r.Handler.InVendor(imp, false); err == nil {
 				r.VersionHandler.SetVersion(imp, testDeps)
 			} else {
 				msg.Warn("Error updating %s: %s", imp, err)
 			}
 		case LocGopath:
-			found, err := r.Handler.OnGopath(imp)
+			found, err := r.Handler.OnGopath(imp, false)
 			if err != nil {
 				msg.Err("Failed to fetch %s: %s", imp, err)
 			}
@@ -878,6 +851,7 @@
 func sliceToQueue(deps []*cfg.Dependency, basepath string) *list.List {
 	l := list.New()
 	for _, e := range deps {
+		msg.Debug("Adding local Import %s to queue", e.Name)
 		l.PushBack(filepath.Join(basepath, filepath.FromSlash(e.Name)))
 	}
 	return l
diff --git a/dependency/resolver_test.go b/dependency/resolver_test.go
index f62b4f5..1867cee 100644
--- a/dependency/resolver_test.go
+++ b/dependency/resolver_test.go
@@ -91,7 +91,7 @@
 	if err != nil {
 		t.Fatalf("No new resolver: %s", err)
 	}
-	l, err := r.ResolveAll(deps)
+	l, err := r.ResolveAll(deps, false)
 	if err != nil {
 		t.Fatalf("Failed to resolve: %s", err)
 	}
diff --git a/glide.go b/glide.go
index a8d39a4..b2001d2 100644
--- a/glide.go
+++ b/glide.go
@@ -250,6 +250,10 @@
 					Name:  "non-interactive",
 					Usage: "Disable interactive prompts.",
 				},
+				cli.BoolFlag{
+					Name:  "skip-test",
+					Usage: "Resolve dependencies in test files.",
+				},
 			},
 			Action: func(c *cli.Context) {
 				if c.Bool("strip-vendor") && !c.Bool("strip-vcs") {
@@ -273,6 +277,7 @@
 				inst.UseCacheGopath = c.Bool("cache-gopath")
 				inst.UpdateVendored = c.Bool("update-vendored")
 				inst.ResolveAllFiles = c.Bool("all-dependencies")
+				inst.ResolveTest = !c.Bool("skip-test")
 				packages := []string(c.Args())
 				insecure := c.Bool("insecure")
 				action.Get(packages, inst, insecure, c.Bool("no-recursive"), c.Bool("strip-vcs"), c.Bool("strip-vendor"), c.Bool("non-interactive"))
@@ -456,6 +461,10 @@
 					Name:  "strip-vendor, v",
 					Usage: "Removes nested vendor and Godeps/_workspace directories. Requires --strip-vcs.",
 				},
+				cli.BoolFlag{
+					Name:  "skip-test",
+					Usage: "Resolve dependencies in test files.",
+				},
 			},
 			Action: func(c *cli.Context) {
 				if c.Bool("strip-vendor") && !c.Bool("strip-vcs") {
@@ -470,6 +479,7 @@
 				installer.UpdateVendored = c.Bool("update-vendored")
 				installer.Home = c.GlobalString("home")
 				installer.DeleteUnused = c.Bool("delete")
+				installer.ResolveTest = !c.Bool("skip-test")
 
 				action.Install(installer, c.Bool("strip-vcs"), c.Bool("strip-vendor"))
 			},
diff --git a/glide.lock b/glide.lock
index 8bb73d6..572094a 100644
--- a/glide.lock
+++ b/glide.lock
@@ -1,5 +1,5 @@
 hash: ebc39e5b2036ba2235316f2897fb9f2e696c6a7d5389416812722cc8ed3dfa21
-updated: 2016-05-05T09:44:44.751721442-04:00
+updated: 2016-06-10T16:27:29.24243625-04:00
 imports:
 - name: github.com/codegangsta/cli
   version: 71f57d300dd6a780ac1856c005c4b518cfd498ec
@@ -9,4 +9,4 @@
   version: 7af28b64c5ec41b1558f5514fd938379822c237c
 - name: gopkg.in/yaml.v2
   version: a83829b6f1293c91addabc89d0571c246397bbf4
-devImports: []
+testImports: []
diff --git a/repo/installer.go b/repo/installer.go
index 82e6f57..867ed99 100644
--- a/repo/installer.go
+++ b/repo/installer.go
@@ -133,7 +133,7 @@
 //
 // This is used when initializing an empty vendor directory, or when updating a
 // vendor directory based on changed config.
-func (i *Installer) Checkout(conf *cfg.Config, useDev bool) error {
+func (i *Installer) Checkout(conf *cfg.Config) error {
 
 	dest := i.VendorPath()
 
@@ -141,7 +141,7 @@
 		return err
 	}
 
-	if useDev {
+	if i.ResolveTest {
 		return ConcurrentUpdate(conf.DevImports, dest, i, conf)
 	}
 
@@ -185,6 +185,7 @@
 
 	// Update imports
 	res, err := dependency.NewResolver(base)
+	res.ResolveTest = i.ResolveTest
 	if err != nil {
 		msg.Die("Failed to create a resolver: %s", err)
 	}
@@ -193,18 +194,63 @@
 	res.VersionHandler = v
 	res.ResolveAllFiles = i.ResolveAllFiles
 	msg.Info("Resolving imports")
-	_, err = allPackages(conf.Imports, res)
+
+	imps, timps, err := res.ResolveLocal(false)
+	if err != nil {
+		msg.Die("Failed to resolve local packages: %s", err)
+	}
+	for _, v := range imps {
+		n := res.Stripv(v)
+		d := conf.Imports.Get(n)
+		if d == nil {
+			nd := &cfg.Dependency{
+				Name: n,
+			}
+			conf.Imports = append(conf.Imports, nd)
+		}
+	}
+	if i.ResolveTest {
+		for _, v := range timps {
+			n := res.Stripv(v)
+			d := conf.Imports.Get(n)
+			if d == nil {
+				d = conf.DevImports.Get(n)
+			}
+			if d == nil {
+				nd := &cfg.Dependency{
+					Name: n,
+				}
+				conf.DevImports = append(conf.DevImports, nd)
+			}
+		}
+	}
+
+	_, err = allPackages(conf.Imports, res, false)
 	if err != nil {
 		msg.Die("Failed to retrieve a list of dependencies: %s", err)
 	}
 
-	if len(conf.DevImports) > 0 {
-		msg.Warn("dev imports not resolved.")
+	if i.ResolveTest {
+		msg.Debug("Resolving test dependencies")
+		_, err = allPackages(conf.DevImports, res, true)
+		if err != nil {
+			msg.Die("Failed to retrieve a list of test dependencies: %s", err)
+		}
 	}
 
 	err = ConcurrentUpdate(conf.Imports, vpath, i, conf)
+	if err != nil {
+		return err
+	}
 
-	return err
+	if i.ResolveTest {
+		err = ConcurrentUpdate(conf.DevImports, vpath, i, conf)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 // List resolves the complete dependency tree and returns a list of dependencies.
@@ -232,7 +278,12 @@
 	res.ResolveAllFiles = i.ResolveAllFiles
 
 	msg.Info("Resolving imports")
-	_, err = allPackages(conf.Imports, res)
+	_, _, err = res.ResolveLocal(false)
+	if err != nil {
+		msg.Die("Failed to resolve local packages: %s", err)
+	}
+
+	_, err = allPackages(conf.Imports, res, false)
 	if err != nil {
 		msg.Die("Failed to retrieve a list of dependencies: %s", err)
 	}
@@ -310,7 +361,7 @@
 }
 
 // allPackages gets a list of all packages required to satisfy the given deps.
-func allPackages(deps []*cfg.Dependency, res *dependency.Resolver) ([]string, error) {
+func allPackages(deps []*cfg.Dependency, res *dependency.Resolver, addTest bool) ([]string, error) {
 	if len(deps) == 0 {
 		return []string{}, nil
 	}
@@ -320,7 +371,7 @@
 		return []string{}, err
 	}
 	vdir += string(os.PathSeparator)
-	ll, err := res.ResolveAll(deps)
+	ll, err := res.ResolveAll(deps, addTest)
 	if err != nil {
 		return []string{}, err
 	}
@@ -347,7 +398,7 @@
 
 // NotFound attempts to retrieve a package when not found in the local vendor/
 // folder. It will attempt to get it from the remote location info.
-func (m *MissingPackageHandler) NotFound(pkg string) (bool, error) {
+func (m *MissingPackageHandler) NotFound(pkg string, addTest bool) (bool, error) {
 	root := util.GetRootFromPackage(pkg)
 
 	// Skip any references to the root package.
@@ -382,6 +433,10 @@
 	msg.Info("Fetching %s into %s", pkg, m.destination)
 
 	d := m.Config.Imports.Get(root)
+	if d == nil && addTest {
+		d = m.Config.DevImports.Get(root)
+	}
+
 	// If the dependency is nil it means the Config doesn't yet know about it.
 	if d == nil {
 		d, _ = m.Use.Get(root)
@@ -389,8 +444,11 @@
 		if d == nil {
 			d = &cfg.Dependency{Name: root}
 		}
-
-		m.Config.Imports = append(m.Config.Imports, d)
+		if addTest {
+			m.Config.DevImports = append(m.Config.DevImports, d)
+		} else {
+			m.Config.Imports = append(m.Config.Imports, d)
+		}
 	}
 	if err := VcsGet(d, dest, m.home, m.cache, m.cacheGopath, m.useGopath); err != nil {
 		return false, err
@@ -401,11 +459,11 @@
 // OnGopath will either copy a package, already found in the GOPATH, to the
 // vendor/ directory or download it from the internet. This is dependent if
 // useGopath on the installer is set to true to copy from the GOPATH.
-func (m *MissingPackageHandler) OnGopath(pkg string) (bool, error) {
+func (m *MissingPackageHandler) OnGopath(pkg string, addTest bool) (bool, error) {
 	// If useGopath is false, we fall back to the strategy of fetching from
 	// remote.
 	if !m.useGopath {
-		return m.NotFound(pkg)
+		return m.NotFound(pkg, addTest)
 	}
 
 	root := util.GetRootFromPackage(pkg)
@@ -438,7 +496,7 @@
 
 // InVendor updates a package in the vendor/ directory to make sure the latest
 // is available.
-func (m *MissingPackageHandler) InVendor(pkg string) error {
+func (m *MissingPackageHandler) InVendor(pkg string, addTest bool) error {
 	root := util.GetRootFromPackage(pkg)
 
 	// Skip any references to the root package.
@@ -449,6 +507,10 @@
 	dest := filepath.Join(m.destination, root)
 
 	d := m.Config.Imports.Get(root)
+	if d == nil && addTest {
+		d = m.Config.DevImports.Get(root)
+	}
+
 	// If the dependency is nil it means the Config doesn't yet know about it.
 	if d == nil {
 		d, _ = m.Use.Get(root)
@@ -457,7 +519,11 @@
 			d = &cfg.Dependency{Name: root}
 		}
 
-		m.Config.Imports = append(m.Config.Imports, d)
+		if addTest {
+			m.Config.DevImports = append(m.Config.DevImports, d)
+		} else {
+			m.Config.Imports = append(m.Config.Imports, d)
+		}
 	}
 
 	if err := VcsUpdate(d, dest, m.home, m.cache, m.cacheGopath, m.useGopath, m.force, m.updateVendored, m.updated); err != nil {
@@ -527,7 +593,7 @@
 // - keeping the already set version
 // - proviting messaging about the version conflict
 // TODO(mattfarina): The way version setting happens can be improved. Currently not optimal.
-func (d *VersionHandler) SetVersion(pkg string, testDep bool) (e error) {
+func (d *VersionHandler) SetVersion(pkg string, addTest bool) (e error) {
 	root := util.GetRootFromPackage(pkg)
 
 	// Skip any references to the root package.
@@ -536,7 +602,7 @@
 	}
 
 	v := d.Config.Imports.Get(root)
-	if testDep {
+	if addTest {
 		if v == nil {
 			v = d.Config.DevImports.Get(root)
 		} else if d.Config.DevImports.Has(root) {
@@ -570,7 +636,7 @@
 	} else if dep != nil {
 		// We've got an imported dependency to use and don't already have a
 		// record of it. Append it to the Imports.
-		if testDep {
+		if addTest {
 			d.Config.DevImports = append(d.Config.DevImports, dep)
 		} else {
 			d.Config.Imports = append(d.Config.Imports, dep)
@@ -584,7 +650,7 @@
 		if sp != "" {
 			dep.Subpackages = []string{sp}
 		}
-		if testDep {
+		if addTest {
 			d.Config.DevImports = append(d.Config.DevImports, dep)
 		} else {
 			d.Config.Imports = append(d.Config.Imports, dep)
diff --git a/repo/set_reference.go b/repo/set_reference.go
index 2856b89..4363459 100644
--- a/repo/set_reference.go
+++ b/repo/set_reference.go
@@ -10,14 +10,14 @@
 
 // SetReference is a command to set the VCS reference (commit id, tag, etc) for
 // a project.
-func SetReference(conf *cfg.Config) error {
+func SetReference(conf *cfg.Config, resolveTest bool) error {
 
 	cwd, err := gpath.Vendor()
 	if err != nil {
 		return err
 	}
 
-	if len(conf.Imports) == 0 {
+	if len(conf.Imports) == 0 && len(conf.DevImports) == 0 {
 		msg.Info("No references set.\n")
 		return nil
 	}
@@ -49,6 +49,15 @@
 		}
 	}
 
+	if resolveTest {
+		for _, dep := range conf.DevImports {
+			if !conf.HasIgnore(dep.Name) {
+				wg.Add(1)
+				in <- dep
+			}
+		}
+	}
+
 	wg.Wait()
 	// Close goroutines setting the version
 	for i := 0; i < concurrentWorkers; i++ {