diff --git a/lib/Associations/Extend.js b/lib/Associations/Extend.js
index a6d42ac1..2e63ab30 100644
--- a/lib/Associations/Extend.js
+++ b/lib/Associations/Extend.js
@@ -214,7 +214,11 @@ function autoFetchInstance(Instance, association, opts, cb) {
 		opts.autoFetchLimit = association.autoFetchLimit;
 	}
 
-	if (opts.autoFetchLimit === 0 || (!opts.autoFetch && !association.autoFetch)) {
+        // autoFetchLimit has been reached -
+        // opts.autoFetch is present, so it overrides association.autoFetch
+        // opts.autoFetch not present, use value from original assn definition
+	if (opts.autoFetchLimit === 0 || (typeof opts.autoFetch !== "undefined" && ! opts.autoFetch)
+                                      || (typeof opts.autoFetch === "undefined" && !association.autoFetch)) {
 		return cb();
 	}
 
diff --git a/lib/Associations/Many.js b/lib/Associations/Many.js
index 1500772d..2a0e2d9b 100644
--- a/lib/Associations/Many.js
+++ b/lib/Associations/Many.js
@@ -475,7 +475,11 @@ function autoFetchInstance(Instance, association, opts, cb) {
 		opts.autoFetchLimit = association.autoFetchLimit;
 	}
 
-	if (opts.autoFetchLimit === 0 || (!opts.autoFetch && !association.autoFetch)) {
+        // autoFetchLimit has been reached -
+        // opts.autoFetch is present, so it overrides association.autoFetch
+        // opts.autoFetch not present, use value from original assn definition
+	if (opts.autoFetchLimit === 0 || (typeof opts.autoFetch !== "undefined" && ! opts.autoFetch)
+                                      || (typeof opts.autoFetch === "undefined" && !association.autoFetch)) {
 		return cb();
 	}
 
diff --git a/lib/Associations/One.js b/lib/Associations/One.js
index df8a3a46..fbf1ebcd 100644
--- a/lib/Associations/One.js
+++ b/lib/Associations/One.js
@@ -297,7 +297,11 @@ function autoFetchInstance(Instance, association, opts, cb) {
 		opts.autoFetchLimit = association.autoFetchLimit;
 	}
 
-	if (opts.autoFetchLimit === 0 || (!opts.autoFetch && !association.autoFetch)) {
+        // autoFetchLimit has been reached -
+        // opts.autoFetch is present, so it overrides association.autoFetch
+        // opts.autoFetch not present, use value from original assn definition
+	if (opts.autoFetchLimit === 0 || (typeof opts.autoFetch !== "undefined" && ! opts.autoFetch)
+                                      || (typeof opts.autoFetch === "undefined" && !association.autoFetch)) {
 		return cb();
 	}
 
diff --git a/lib/Model.js b/lib/Model.js
index c684c4d2..8dcac8d2 100644
--- a/lib/Model.js
+++ b/lib/Model.js
@@ -81,7 +81,7 @@ function Model(opts) {
 		}
 
 		var assoc_opts = {
-			autoFetch      : inst_opts.autoFetch || false,
+			autoFetch      : inst_opts.autoFetch,
 			autoFetchLimit : inst_opts.autoFetchLimit,
 			cascadeRemove  : inst_opts.cascadeRemove
 		};
@@ -92,6 +92,21 @@ function Model(opts) {
 			ExtendAssociation.extend(model, instance, opts.driver, extend_associations, assoc_opts);
 		};
 
+                // check all the auto-fetch associations have been populated for the given instance
+                var hasAutoFetchAssociationsLoaded = function(instance) {
+                  var checkAssn = function(associations) {
+                    for (var assn = 0; assn < associations.length; assn++) {
+                      if(associations[assn].autoFetch && ! instance.hasOwnProperty(associations[assn].name)) {
+                        return false;
+                      }
+                    };
+                    return true;
+                  };
+                  return checkAssn(one_associations) &&
+                         checkAssn(many_associations) &&
+                         checkAssn(extend_associations);
+                };
+
 		var pending  = 2, create_err = null;
 		var instance = new Instance(model, {
 			uid                    : inst_opts.uid, // singleton unique id
@@ -112,6 +127,7 @@ function Model(opts) {
 			extend_associations    : extend_associations,
 			association_properties : association_properties,
 			setupAssociations      : setupAssociations,
+			hasAutoFetchAssociationsLoaded: hasAutoFetchAssociationsLoaded,
 			fieldToPropertyMap     : fieldToPropertyMap,
 			keyProperties          : keyProperties
 		});
@@ -275,9 +291,6 @@ function Model(opts) {
 			conditions[prop.mapsTo] = ids[i];
 		}
 
-		if (!options.hasOwnProperty("autoFetch")) {
-			options.autoFetch = opts.autoFetch;
-		}
 		if (!options.hasOwnProperty("autoFetchLimit")) {
 			options.autoFetchLimit = opts.autoFetchLimit;
 		}
@@ -299,7 +312,8 @@ function Model(opts) {
 
 			Singleton.get(uid, {
 				cache      : (options.hasOwnProperty("cache") ? options.cache : opts.cache),
-				save_check : opts.settings.get("instance.cacheSaveCheck")
+				save_check : opts.settings.get("instance.cacheSaveCheck"),
+                                autoFetch  : options.autoFetch
 			}, function (cb) {
 				return createInstance(data[0], {
 					uid            : uid,
@@ -406,15 +420,23 @@ function Model(opts) {
 					uid += "/" + data[opts.keys[i]];
 				}
 
-                                // Now we can do the cache lookup
+				// When there is extra_info we need a slightly longer uid for the Singleton lookup
+				if(merge && options.extra_info) {
+					for(var j=0; j<options.extra_info.id.length; j++) {
+						uid += "/" + options.extra_info.id[j];
+					}
+				}
+
+				// Now we can do the cache lookup
 				Singleton.get(uid, {
 					cache      : options.cache,
-					save_check : opts.settings.get("instance.cacheSaveCheck")
+					save_check : opts.settings.get("instance.cacheSaveCheck"),
+					autoFetch  : options.autoFetch
 				}, function (cb) {
 					return createInstance(data, {
 						uid            : uid,
 						autoSave       : opts.autoSave,
-						autoFetch      : (options.autoFetchLimit === 0 ? false : (options.autoFetch || opts.autoFetch)),
+						autoFetch      : (options.autoFetchLimit === 0 ? false : options.autoFetch),
 						autoFetchLimit : options.autoFetchLimit,
 						cascadeRemove  : options.cascadeRemove,
 						extra          : options.extra,
diff --git a/lib/Singleton.js b/lib/Singleton.js
index 6fbc5449..b08ec3c3 100644
--- a/lib/Singleton.js
+++ b/lib/Singleton.js
@@ -13,17 +13,26 @@ exports.get = function (key, opts, createCb, returnCb) {
 	if (opts && opts.cache === false) {
 		return createCb(returnCb);
 	}
+ 	// we've got a custom autoFetch setting for this get/find so don't use the cache
+	if(typeof opts.autoFetch !== "undefined") {
+		return createCb(returnCb);
+	}
 	if (map.hasOwnProperty(key)) {
 		if (opts && opts.save_check && typeof map[key].o.saved === "function" && !map[key].o.saved()) {
-			// if not saved, don't return it, fetch original from db
+			// if not saved, don't return it, fetch original from db, but don't refresh the cache
 			return createCb(returnCb);
 		} else if (map[key].t !== null && map[key].t <= Date.now()) {
 			delete map[key];
-		} else  {
-			return returnCb(null, map[key].o);
+                } else {
+			var instance = map[key].o;
+			if(instance.__opts.hasAutoFetchAssociationsLoaded(instance)) {
+				// instance in cache has all auto-fetch associations populated - we can re-use it
+				return returnCb(null, instance);
+			}
 		}
 	}
 
+        // Can't re-use item in cache - or it's not in cache - re-fetch from db & load the cache
 	createCb(function (err, value) {
 		if (err) return returnCb(err);
 
diff --git a/test/integration/association-extend.js b/test/integration/association-extend.js
index a14f91e5..275d689f 100644
--- a/test/integration/association-extend.js
+++ b/test/integration/association-extend.js
@@ -6,6 +6,7 @@ describe("Model.extendsTo()", function() {
 	var db = null;
 	var Person = null;
 	var PersonAddress = null;
+        var johnId = null;
 
 	var setup = function () {
 		return function (done) {
@@ -24,7 +25,7 @@ describe("Model.extendsTo()", function() {
 					name: "John Doe"
 				}, function (err, person) {
 					should.not.exist(err);
-
+                                        johnId = person[Person.id];
 					return person.setAddress(new PersonAddress({
 						street : "Liberty",
 						number : 123
@@ -97,6 +98,49 @@ describe("Model.extendsTo()", function() {
 			Person.find().first(function (err, John) {
 				should.equal(err, null);
 
+				John.should.not.have.property("address");
+
+				John.getAddress(function (err, Address) {
+					should.equal(err, null);
+					Address.should.be.a("object");
+					Address.should.have.property("street", "Liberty");
+
+					return done();
+				});
+			});
+		});
+
+		it("should honor autoFetch:TRUE on find", function (done) {
+			Person.find({name:"John Doe"}, {autoFetch:true}).first(function (err, John) {
+				should.equal(err, null);
+
+				John.should.have.property("address");
+
+				John.getAddress(function (err, Address) {
+					should.equal(err, null);
+					Address.should.be.a("object");
+					Address.should.have.property("street", "Liberty");
+
+					return done();
+				});
+			});
+		});
+
+		it("should honor autoFetch:FALSE on find", function (done) {
+			Person.find({name:"John Doe"}, {autoFetch:false}).first(function (err, John) {
+				should.equal(err, null);
+
+				John.should.not.have.property("address");
+				return done();
+			});
+		});
+
+		it("should honor autoFetch:TRUE on get", function (done) {
+			Person.get(johnId, {autoFetch:true}, function (err, John) {
+				should.equal(err, null);
+
+				John.should.have.property("address");
+
 				John.getAddress(function (err, Address) {
 					should.equal(err, null);
 					Address.should.be.a("object");
@@ -107,6 +151,15 @@ describe("Model.extendsTo()", function() {
 			});
 		});
 
+		it("should honor autoFetch:FALSE on get", function (done) {
+			Person.get(johnId, {autoFetch:false}, function (err, John) {
+				should.equal(err, null);
+
+				John.should.not.have.property("address");
+				return done();
+			});
+		});
+
 		it("should return error if not found", function (done) {
 			Person.find().first(function (err, John) {
 				should.equal(err, null);
diff --git a/test/integration/association-hasmany-extra.js b/test/integration/association-hasmany-extra.js
index 5ba99a98..2ae062f1 100644
--- a/test/integration/association-hasmany-extra.js
+++ b/test/integration/association-hasmany-extra.js
@@ -7,25 +7,43 @@ describe("hasMany extra properties", function() {
 	var Person = null;
 	var Pet    = null;
 
+	var data = { adopted: true };
+	var since14 = new Date("2014-01-01");
+	var since15 = new Date("1915-04-25");
+
 	var setup = function (opts) {
 		opts = opts || {};
 		return function (done) {
-			db.settings.set('instance.cache', false);
 
 			Person = db.define('person', {
-				name    : String,
+				name    : String
 			}, opts);
 			Pet = db.define('pet', {
 				name    : String
-			});
+			}, opts);
 			Person.hasMany('pets', Pet, {
 				since   : Date,
 				data    : Object
 			});
 
-			return helper.dropSync([ Person, Pet ], done);
-		};
-	};
+			return helper.dropSync([ Person, Pet ], function(err) {
+                if (err) return done(err);
+				Person.create([{name	: "John"},
+							   {name	: "Jane"}], function (err, people) {
+
+	                if (err) return done(err);
+					Pet.create([{name : "Deco"},
+								{name : "Mutt"}], function (err, pets) {
+
+		                if (err) return done(err);
+						people[0].addPets(pets, { since : since14, data: data }, function (err) {
+							people[1].addPets(pets, { since : since15, data: data }, done);
+						});
+					});
+				});
+			});
+        };
+    };
 
 	before(function(done) {
 		this.timeout(4000);
@@ -36,45 +54,44 @@ describe("hasMany extra properties", function() {
 		});
 	});
 
+  [true, false].forEach(function(cache) {
 	describe("if passed to addAccessor", function () {
-		before(setup());
+		before(setup( {cache:cache}));
 
-		it("should be added to association", function (done) {
-			Person.create([{
-				name    : "John"
-			}], function (err, people) {
-				Pet.create([{
-					name : "Deco"
-				}, {
-					name : "Mutt"
-				}], function (err, pets) {
-					var data = { adopted: true };
+		it("should be added to association and correctly retrieved " + (cache ? "with" : "without") + " the cache", function (done) {
+		  Person.find({ name: "John" }, { autoFetch : true }).first(function (err, John) {
+			should.equal(err, null);
 
-					people[0].addPets(pets, { since : new Date(), data: data }, function (err) {
-						should.equal(err, null);
+			John.should.have.property("pets");
+			should(Array.isArray(John.pets));
 
-						Person.find({ name: "John" }, { autoFetch : true }).first(function (err, John) {
-							should.equal(err, null);
+			John.pets.length.should.equal(2);
 
-							John.should.have.property("pets");
-							should(Array.isArray(pets));
+			John.pets[0].should.have.property("name");
+			John.pets[0].should.have.property("extra");
+			John.pets[0].extra.should.be.a("object");
+			John.pets[0].extra.should.have.property("since");
+			should(John.pets[0].extra.since instanceof Date);
+            should.equal(John.pets[0].extra.since.getFullYear(), since14.getFullYear());
 
-							John.pets.length.should.equal(2);
+			should.equal(typeof John.pets[0].extra.data, 'object');
+			should.equal(JSON.stringify(data), JSON.stringify(John.pets[0].extra.data));
 
-							John.pets[0].should.have.property("name");
-							John.pets[0].should.have.property("extra");
-							John.pets[0].extra.should.be.a("object");
-							John.pets[0].extra.should.have.property("since");
-							should(John.pets[0].extra.since instanceof Date);
+			// Do a second retrieve (which will break the cache)
+			Person.find({name: "Jane"}, {autoFetch:true}).first(function(err, Jane) {
+			  should.equal(err, null);
 
-							should.equal(typeof John.pets[0].extra.data, 'object');
-							should.equal(JSON.stringify(data), JSON.stringify(John.pets[0].extra.data));
+			  Jane.pets[0].should.have.property("name");
+			  Jane.pets[0].should.have.property("extra");
+			  Jane.pets[0].extra.should.be.a("object");
+			  Jane.pets[0].extra.should.have.property("since");
+			  should(Jane.pets[0].extra.since instanceof Date);
+			  should.equal(Jane.pets[0].extra.since.getFullYear(), since15.getFullYear());
 
-							return done();
-						});
-					});
-				});
-			});
-		});
-	});
+			  return done();
+            })
+		  });
+        });
+    });
+  });
 });
diff --git a/test/integration/association-hasmany.js b/test/integration/association-hasmany.js
index 167d79d8..0eeb24ed 100644
--- a/test/integration/association-hasmany.js
+++ b/test/integration/association-hasmany.js
@@ -10,6 +10,7 @@ describe("hasMany", function () {
 	var db     = null;
 	var Person = null;
 	var Pet    = null;
+        var johnId = null;
 
 	before(function(done) {
 		helper.connect(function (connection) {
@@ -62,9 +63,12 @@ describe("hasMany", function () {
 						surname : "Dean",
 						age     : 18
 					}], function (err) {
-						Person.find({ name: "Jane" }, function (err, people) {
-							Pet.find({ name: "Mutt" }, function (err, pets) {
-								people[0].addPets(pets, done);
+ 						Person.find({ name: "John"}, function(err, people) {
+							johnId = people[0][Person.id];
+							Person.find({ name: "Jane" }, function (err, people) {
+								Pet.find({ name: "Mutt" }, function (err, pets) {
+									people[0].addPets(pets, done);
+								});
 							});
 						});
 					});
@@ -553,7 +557,7 @@ describe("hasMany", function () {
 				autoFetchPets : true
 			}));
 
-			it("should fetch associations", function (done) {
+			it("should fetch associations on find", function (done) {
 				Person.find({ name: "John" }).first(function (err, John) {
 					should.equal(err, null);
 
@@ -565,6 +569,37 @@ describe("hasMany", function () {
 				});
 			});
 
+			it("should fetch associations on get", function (done) {
+				Person.get(johnId, function (err, John) {
+					should.equal(err, null);
+
+					John.should.have.property("pets");
+					should(Array.isArray(John.pets));
+					John.pets.length.should.equal(2);
+
+					return done();
+				});
+			});
+
+			it("should honor autoFetch FALSE on find", function (done) {
+
+				Person.find({ name: "John" }, {autoFetch:false}).first(function (err, John) {
+					should.equal(err, null);
+
+					John.should.not.have.property("pets");
+					return done();
+				});
+			});
+
+			it("should honor autoFetch FALSE on get", function (done) {
+				Person.get(johnId, {autoFetch: false}, function (err, John) {
+					should.equal(err, null);
+
+					John.should.not.have.property("pets");
+					return done();
+				});
+			});
+
 			it("should save existing", function (done) {
 				Person.create({ name: 'Bishan' }, function (err) {
 					should.not.exist(err);
diff --git a/test/integration/association-hasone-recursive.js b/test/integration/association-hasone-recursive.js
new file mode 100644
index 00000000..747688bb
--- /dev/null
+++ b/test/integration/association-hasone-recursive.js
@@ -0,0 +1,230 @@
+var ORM    = require('../../');
+var helper = require('../support/spec_helper');
+var should = require('should');
+var async  = require('async');
+var _      = require('lodash');
+
+describe("hasOne", function() {
+	var db     = null;
+	var Animal = null;
+
+	var setup = function (cache) {
+		return function (done) {
+			db.settings.set('instance.cache', cache);
+			db.settings.set('instance.returnAllErrors', true);
+
+		        Animal = db.define('animal', {
+                          id        : {type : "integer", key:true},
+			  name      : {type : "text",    size:"255"},
+                          damId     : {type : "integer"},
+                          sireId    : {type : "integer"}
+			});
+
+		        Animal.hasOne('sire', Animal, {field: 'sireId', autoFetch:true});
+		        Animal.hasOne('dam',  Animal, {field: 'damId',  autoFetch:false});
+
+		        helper.dropSync([Animal], function(err) {
+                          if (err) return done(err);
+                          Animal.create([{ id:1,   name: 'Bronson',  sireId:10, damId:20},
+
+                                         { id:10,  name: 'McTavish', sireId:11, damId:12},
+                                         { id:11, name:'Todd'},
+                                         { id:12, name:'Jemima'},
+
+                                         { id:20,  name: 'Suzy',    sireId:21,  damId:22},
+                                         { id:21,  name:'Liam'},
+                                         { id:22,  name:'Glencora'}
+                                        ], done);
+                        });
+		};
+	};
+
+	before(function(done) {
+	  helper.connect(function (connection) {
+	    db = connection;
+	    done();
+	  });
+	});
+
+        [false, 1].forEach(function(cache) {
+
+	  describe("recursive hasOne() with " + (cache ? "" : "out ") + "cache", function () {
+	    before(setup(cache));
+
+	    it("should get Bronson's Sire but not Dam", function (done) {
+	      Animal.find({name: "Bronson"}, function(err, animals) {
+                should.not.exist(err);
+
+                animals[0].name.should.equal("Bronson");
+
+                // All of Bronson's Sire & some of his Dam stuff should be present
+                animals[0].sireId.should.equal(10);
+                animals[0].damId.should.equal(20);
+
+                animals[0].should.have.property("sire");
+                animals[0].should.not.have.property("dam");  // no auto-fetch
+
+                animals[0].sire.name.should.equal("McTavish");
+
+                // Bronson's paternal GrandSire & GrandDam shouldn't be present - autoFetchLimit
+                animals[0].sire.should.not.have.property("sire");
+                animals[0].sire.should.not.have.property("dam");
+
+                // but Bronson's paternal GrandSire & GrandDam ID's should be known
+                animals[0].sire.sireId.should.equal(11);
+                animals[0].sire.damId.should.equal(12);
+
+                return done();
+	      });
+	    });
+
+	    it("should honor auto-fetch override:TRUE on find", function (done) {
+	      Animal.find({name: "Bronson"}, {autoFetch:true}, function(err, animals) {
+                should.not.exist(err);
+
+                animals[0].name.should.equal("Bronson");
+
+                // All of Bronson's Sire & Dam stuff should be present
+                animals[0].sireId.should.equal(10);
+                animals[0].damId.should.equal(20);
+
+                animals[0].should.have.property("sire");
+                animals[0].should.have.property("dam");  // no auto-fetch - overridden for this find
+
+                animals[0].sire.name.should.equal("McTavish");
+                animals[0].dam.name.should.equal("Suzy");
+
+                // Bronson's paternal GrandSire & GrandDam shouldn't be present - autoFetchLimit
+                animals[0].sire.should.not.have.property("sire");
+                animals[0].sire.should.not.have.property("dam");
+
+                // but Bronson's paternal GrandSire & GrandDam ID's should be known
+                animals[0].sire.sireId.should.equal(11);
+                animals[0].sire.damId.should.equal(12);
+
+                return done();
+	      });
+	    });
+
+	    it("should honor auto-fetch override:FALSE on find", function (done) {
+	      Animal.find({name: "Bronson"}, {autoFetch:false}, function(err, animals) {
+                should.not.exist(err);
+
+                animals[0].name.should.equal("Bronson");
+
+                // Only Bronson's Sire & Dam IDs should be present
+                animals[0].sireId.should.equal(10);
+                animals[0].damId.should.equal(20);
+
+                animals[0].should.not.have.property("sire");
+                animals[0].should.not.have.property("dam");
+
+                return done();
+	      });
+	    });
+
+	    it("should honor auto-fetch override:TRUE on get", function (done) {
+	      Animal.get(1, {autoFetch:true}, function(err, Bronson) {
+                should.not.exist(err);
+
+                Bronson.name.should.equal("Bronson");
+
+                // All of Bronson's Sire & Dam stuff should be present
+                Bronson.sireId.should.equal(10);
+                Bronson.damId.should.equal(20);
+
+                Bronson.should.have.property("sire");
+                Bronson.should.have.property("dam");  // no auto-fetch - overridden for this find
+
+                Bronson.sire.name.should.equal("McTavish");
+                Bronson.dam.name.should.equal("Suzy");
+
+                // Bronson's paternal GrandSire & GrandDam shouldn't be present - autoFetchLimit
+                Bronson.sire.should.not.have.property("sire");
+                Bronson.sire.should.not.have.property("dam");
+
+                // but Bronson's paternal GrandSire & GrandDam ID's should be known
+                Bronson.sire.sireId.should.equal(11);
+                Bronson.sire.damId.should.equal(12);
+
+                return done();
+	      });
+	    });
+
+	    it("should honor auto-fetch override:FALSE on get", function (done) {
+	      Animal.get(1, {autoFetch:false}, function(err, Bronson) {
+                should.not.exist(err);
+
+                Bronson.name.should.equal("Bronson");
+
+                // Only Bronson's Sire & Dam IDs should be present
+                Bronson.sireId.should.equal(10);
+                Bronson.damId.should.equal(20);
+
+                Bronson.should.not.have.property("sire");
+                Bronson.should.not.have.property("dam");
+
+                return done();
+	      });
+	    });
+
+	    it("should get McTavish's Sire but not Dam", function (done) {
+	      Animal.find({name: "McTavish"}, function(err, animals) {
+                should.not.exist(err);
+
+                animals[0].name.should.equal("McTavish");
+
+                // All of McTavish's Sire & some of his Dam stuff should be present
+                animals[0].sireId.should.equal(11);
+                animals[0].damId.should.equal(12);
+
+                animals[0].should.have.property("sire");      // now fixed by stueynz
+                animals[0].should.not.have.property("dam");   // no auto-fetch
+
+                animals[0].sire.name.should.equal("Todd");    // just to be sure
+
+                // Let's make sure the cache is still working...
+                Animal.get(animals[0].id, function(err, McTavish) {
+                  should.not.exist(err);
+
+                  if(cache) {
+                    McTavish.should.equal(animals[0]);
+                  } else {
+                    McTavish.should.not.equal(animals[0]);
+                  }
+		  return done();
+                });
+	      });
+	    });
+
+	    it("should get Suzy's Sire but not Dam", function (done) {
+	      Animal.find({name: "Suzy"}, function(err, animals) {
+                should.not.exist(err);
+
+                animals[0].name.should.equal("Suzy");
+
+                // All of Suzy's Sire & Dam stuff should be present
+                animals[0].sireId.should.equal(21);
+                animals[0].damId.should.equal(22);
+
+                animals[0].should.have.property("sire")         // now fixed by stueynz
+                animals[0].should.not.have.property("dam");     // no auto-fetch
+
+                animals[0].sire.name.should.equal("Liam");      // just to be sure
+
+                // Let's make sure the cache is still working...
+                Animal.get(animals[0].id, function(err, Suzy) {
+                  should.not.exist(err);
+
+                  if(cache) {
+                    Suzy.should.equal(animals[0]);
+                  } else {
+                    Suzy.should.not.equal(animals[0]);
+                  }
+		  return done();
+                });
+	      });
+	    });
+	  });
+        });
+});
diff --git a/test/integration/association-hasone.js b/test/integration/association-hasone.js
index 91226471..4ce1e418 100644
--- a/test/integration/association-hasone.js
+++ b/test/integration/association-hasone.js
@@ -174,6 +174,27 @@ describe("hasOne", function() {
 				});
 			});
 
+			describe("autofetching get override", function() {
+				it((!af ? "should" : "shouldn't") + " be done", function (done) {
+					Leaf.get(leafId, {autoFetch: !af}, function (err, leaf) {
+						should.not.exist(err);
+						should.equal(typeof leaf.tree, !af ? 'object' : 'undefined');
+
+						return done();
+					});
+				});
+			});
+			describe("autofetching find override", function() {
+				it((!af ? "should" : "shouldn't") + " be done", function (done) {
+					Leaf.find({size:14}, {autoFetch: !af}, function (err, leaves) {
+						should.not.exist(err);
+						should.equal(typeof leaves[0].tree, !af ? 'object' : 'undefined');
+
+						return done();
+					});
+				});
+			});
+
 			describe("associating by parent id", function () {
 				var tree = null;