private IRedisClient TrackInstance(MethodBase callingMethodType, string method, IRedisClient instance)
        {
            // track
            var frame = new TrackingFrame()
            {
                Id = Guid.NewGuid(),
                Initialised = DateTime.Now,
                ProvidedToInstanceOfType = callingMethodType.DeclaringType,
            };
            lock (this.trackingFrames)
            {
                this.trackingFrames.Add(frame);
            }

            // proxy
            var proxy = new TrackingRedisClientProxy(instance, frame.Id);
            proxy.BeforeInvoke += (sender, args) =>
            {
                if (string.Compare("Dispose", args.MethodInfo.Name, StringComparison.InvariantCultureIgnoreCase) != 0)
                {
                    return;
                }
                lock (this.trackingFrames)
                {
                    this.trackingFrames.Remove(frame);
                }
                var duration = DateTime.Now - frame.Initialised;

                Logger.DebugFormat("{0,18} Disposed {1} released from instance of type {2} checked out for {3}", method, frame.Id, frame.ProvidedToInstanceOfType.FullName, duration);
            };

            Logger.DebugFormat("{0,18} Tracking {1} allocated to instance of type {2}", method, frame.Id, frame.ProvidedToInstanceOfType.FullName);
            return proxy.GetTransparentProxy() as IRedisClient;
        }

 private void SetKey(IRedisClient client, int count)
 {
     for(int i = 1; i <= count; i++)
     {
         client.Set("key" + i, count);
     }
 }

 /// <summary>
 /// Lock
 /// </summary>
 /// <param name="client"></param>
 /// <param name="globalLockKey"></param>
 /// <param name="acquisitionTimeout">in seconds</param>
 /// <param name="lockTimeout">in seconds</param>
 public DisposableDistributedLock(IRedisClient client, string globalLockKey, int acquisitionTimeout, int lockTimeout)
 {
     myLock = new DistributedLock();
     myClient = client;
     this.globalLockKey = globalLockKey;
     lockState = myLock.Lock(globalLockKey, acquisitionTimeout, lockTimeout, out lockExpire, myClient);
 }

 protected static void FlushRedis(IRedisClient redisClient)
 {
     foreach (var key in redisClient.SearchKeys("recommendify-test*"))
     {
         redisClient.Remove(key);
     }
 }

        private static void AssertClientHasHost(IRedisClient client, string hostWithOptionalPort)
        {
            var parts = hostWithOptionalPort.Split(':');
            var port = parts.Length > 1 ? int.Parse(parts[1]) : RedisNativeClient.DefaultPort;

            Assert.That(client.Host, Is.EqualTo(parts[0]));
            Assert.That(client.Port, Is.EqualTo(port));
        }

        public IRedisClient<string> GetClient()
        {
            if (_client == null || _client.IsDisposed || _invalidated)
            _client = new RedisClient(_host, _port);

              _invalidated = false;
              return _client;
        }

 public RedisJobFetcher(
     IRedisClient redis, 
     IEnumerable<string> queueNames, 
     TimeSpan fetchTimeout)
 {
     _redis = redis;
     _queueNames = queueNames.ToList();
     _fetchTimeout = fetchTimeout;
 }

        public RedisTempDataProvider(RedisTempDataProviderOptions options, IRedisClient redis)
        {
            if (options == null) throw new ArgumentNullException("options");
            if (redis == null) throw new ArgumentNullException("redis");

            // Copy so that references can't be modified outside of thsi class.
            this.options = new RedisTempDataProviderOptions(options);
            this.redis = redis;
        }

 public Base(int maxNeighbours, string redisPrefix, IRedisClient redisClient)
 {
     RedisClient = redisClient;
     MaxNeighbours = maxNeighbours;
     RedisPrefix = redisPrefix;
     InputMatrices = new Dictionary<string, InputMatrix>();
     SimilarityMatrix = new SimilarityMatrix(
             new Options {Key = "similarities", MaxNeighbours = MaxNeighbours, RedisPrefix = RedisPrefix},
             redisClient);
 }

        public RedisResultCollection(IRedisClient client, string filePrefix)
        {
            this.client = client;
            this.filePrefix = filePrefix;
            this.testRunInfos = new RedisInfoCollection<TestRun>(client, () => new TestRun());

            if(!Directory.Exists(filePrefix))
                Directory.CreateDirectory(filePrefix);

            ForceUnlock();
        }

        protected void LoadBasicStrings(IRedisClient redis)
        {
            int A = 'A';
            int Z = 'Z';
            var letters = (Z - A + 1).Times(i => ((char)(i + A)).ToString());
            var numbers = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };

            var pos = 0;
            letters.Each(x => redis.Set("string:letters/" + x, x));
            numbers.Each(x => redis.Set("string:numbers/" + pos++, x));
        }

        public void RedisBackedFurnaceItemsTestsSetUp()
        {
            Client = Substitute.For<IRedisClient>();
            ContentTypes = Substitute.For<IFurnaceContentTypes>();
            ContentType = new ContentType { Name = ContentTypeName, Namespace = ContentTypeNamespace };

            SiteConfiguration = Substitute.For<IFurnaceSiteConfiguration>();
            SiteConfiguration.DefaultSiteCulture.Returns(new CultureInfo("en-AU"));

            Sut = new RedisBackedFurnaceItems(Client, SiteConfiguration, ContentTypes);
        }

        public RedisFetchedJob(IRedisClient redis, string jobId, string queue)
        {
            if (redis == null) throw new ArgumentNullException("redis");
            if (jobId == null) throw new ArgumentNullException("jobId");
            if (queue == null) throw new ArgumentNullException("queue");

            _redis = redis;

            JobId = jobId;
            Queue = queue;
        }

        public override void Execute(IRedisClient client)
        {
            try
            {
                if (VoidReturnCommand != null)
                {
                    VoidReturnCommand(client);

                }
                else if (IntReturnCommand != null)
                {
                    IntReturnCommand(client);

                }
                else if (LongReturnCommand != null)
                {
                    LongReturnCommand(client);

                }
                else if (DoubleReturnCommand != null)
                {
                    DoubleReturnCommand(client);

                }
                else if (BytesReturnCommand != null)
                {
                    BytesReturnCommand(client);

                }
                else if (StringReturnCommand != null)
                {
                    StringReturnCommand(client);

                }
                else if (MultiBytesReturnCommand != null)
                {
                    MultiBytesReturnCommand(client);

                }
                else if (MultiStringReturnCommand != null)
                {
                    MultiStringReturnCommand(client);
                }
                else if (DictionaryStringReturnCommand != null)
                {
                    DictionaryStringReturnCommand(client);
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex);
            }
        }

 public CCMatrix(Options options, IRedisClient redisClient)
 {
     this.options = options;
     this.redisClient = redisClient;
     Matrix = new SparseMatrix(
             new Options
             {
                 Key = string.Format("{0}:{1}", options.Key, "ccmatrix"),
                 MaxNeighbours = options.MaxNeighbours,
                 RedisPrefix = options.RedisPrefix,
                 Weight = options.Weight
             }, redisClient);
 }

        public ExecOnceOnly(IRedisClientsManager redisManager, string hashKey, string correlationId)
        {
            redisManager.ThrowIfNull("redisManager");
            hashKey.ThrowIfNull("hashKey");

            this.hashKey = hashKey;
            this.correlationId = correlationId;

            if (correlationId != null)
            {
                redis = redisManager.GetClient();
                var exists = !redis.SetEntryInHashIfNotExists(hashKey, correlationId, Flag);
                if (exists)
                    throw HttpError.Conflict("Request {0} has already been processed".Fmt(correlationId));
            }
        }

        public AppStoresWapUIServiceTest()
        {
            _redisServiceMock = new Mock<IRedisService>();
            redisService = _redisServiceMock.Object;

            _redisServiceMock2 = new Mock<IRedisService2>();
            redisService2 = _redisServiceMock2.Object;

            _redisClientMock = new Mock<IRedisClient>();
            redisClient = _redisClientMock.Object;

            _appStoreUIServiceMock = new Mock<IAppStoreUIService>();
            appStoreUIService = _appStoreUIServiceMock.Object;

            _logServiceMock = new Mock<ILogger>();
            logService = _logServiceMock.Object;

            _fileServiceMock = new Mock<IFileService>();
            fileService = _fileServiceMock.Object;

            _fullTextSearchServiceMock = new Mock<IFullTextSearchService>();
            fullTextSearchService = _fullTextSearchServiceMock.Object;

            _requestRepoMock = new Mock<IRequestRepository>();
            requestRepo = _requestRepoMock.Object;

            appStoreUIRealService = new AppStoreUIService(fs, redisReal);

            sesionRepository = new Mock<ISessionRepository>();
            sesionRepositoryReal = new SessionRepository();

            cookieServiceReal =new CookieService();
            cookieService = new Mock<ICookieService>();

            appStoreServiceReal = new AppStoreService(fs, redisReal, appStoreUIRealService, new FullTextSearchService(redisReal),new IMEICacheService(redisReal));
            appStoreServiceReal.RedisService2 = new RedisService2();
            appStoreService = new AppStoreService(fs, redisService, appStoreUIRealService, new FullTextSearchService(redisService), new IMEICacheService(redisReal));
            appStoreService.RedisService2 = redisService2;

            appStoresWapUIServiceReal = new AppStoresWapUISerivces(appStoreUIRealService, redisReal, appStoreServiceReal, sesionRepositoryReal, cookieServiceReal, new FullTextSearchService(redisReal));
            appStoresWapUIServiceReal.RedisService2 = new RedisService2();
            appStoresWapUIService = new AppStoresWapUISerivces(appStoreUIService, redisService, appStoreService, sesionRepository.Object, cookieService.Object, fullTextSearchService);

            appStoresWapUIService.RedisService2 = redisService2;
            Bootstrapper.Start();
            redisReal.FlushAll();
        }

        protected void LoadDifferentKeyTypes(IRedisClient client)
        {
            var items = new List<string> { "one", "two", "three", "four" };
            var map = new Dictionary<string, string> {
                        {"A","one"},
                        {"B","two"},
                        {"C","three"},
                        {"D","four"},
                    };

            items.ForEach(x => Redis.Set("urn:testkeytypes:string:" + x, x));
            items.ForEach(x => Redis.AddItemToList("urn:testkeytypes:list", x));
            items.ForEach(x => Redis.AddItemToSet("urn:testkeytypes:set", x));
            var i = 0;
            items.ForEach(x => Redis.AddItemToSortedSet("urn:testkeytypes:zset", x, i++));
            Redis.SetRangeInHash("urn:testkeytypes:hash", map);
        }

		private static void UseClient(IRedisClient client, int clientNo)
		{
			var host = "";

			try
			{
				host = client.Host;

				Debug.WriteLine(String.Format("Client '{0}' is using '{1}'", clientNo, client.Host));
				var differentDbs = new[] { 1, 0, 2 };

				foreach (var db in differentDbs)
				{
					client.Db = db;

					var testClientKey = "test:" + host + ":" + clientNo;
					client.SetEntry(testClientKey, testData);
					var result = client.GetValue(testClientKey) ?? "";
					LogResult(db, testClientKey, result);

					var testClientSetKey = "test+set:" + host + ":" + clientNo;
					client.AddItemToSet(testClientSetKey, testData);
					var resultSet = client.GetAllItemsFromSet(testClientSetKey);
					LogResult(db, testClientKey, resultSet.ToList().FirstOrDefault());

					var testClientListKey = "test+list:" + host + ":" + clientNo;
					client.AddItemToList(testClientListKey, testData);
					var resultList = client.GetAllItemsFromList(testClientListKey);
					LogResult(db, testClientKey, resultList.FirstOrDefault());

				}
			}
			catch (NullReferenceException ex)
			{
				Debug.WriteLine("NullReferenceException StackTrace: \n" + ex.StackTrace);
                Assert.Fail("NullReferenceException");
            }
			catch (Exception ex)
			{
				Debug.WriteLine(String.Format("\t[[email protected]{0}]: {1} => {2}",
					host, ex.GetType().Name, ex));
                Assert.Fail("Exception");
			}
		}

        public AppStoresServiceTest()
        {
            _redisServiceMock = new Mock<IRedisService>();
            redisService = _redisServiceMock.Object;

            _redisServiceMock2 = new Mock<IRedisService2>();
            redisService2 = _redisServiceMock2.Object;

            _redisClientMock = new Mock<IRedisClient>();
            redisClient = _redisClientMock.Object;

            _appStoreUIServiceMock = new Mock<IAppStoreUIService>();
            appStoreUIService = _appStoreUIServiceMock.Object;

            _fileServiceMock = new Mock<IFileService>();
            fileService = _fileServiceMock.Object;

            _logServiceMock = new Mock<ILogger>();
            logService = _logServiceMock.Object;

            _requestRepoMock = new Mock<IRequestRepository>();
            requestRepo = _requestRepoMock.Object;

            _fullTextSearchServiceMock = new Mock<IFullTextSearchService>();
            fullTextSearchService = _fullTextSearchServiceMock.Object;
            _imeiCacheServiceMock = new Mock<IIMEICacheService>();
            imeiCacheService = _imeiCacheServiceMock.Object;

            appStoreUIRealService = new AppStoreUIService(fs, redis);
            appStoreUIRealService.RedisService2 = redis2;
            appStoreRealService = new AppStoreService(fs, redis, appStoreUIRealService, fullTextSearchService, imeiCacheService);
            appStoreRealService.RedisService2 = redis2;

            appStoreMockService = new AppStoreService(_fileServiceMock.Object, _redisServiceMock.Object,
                _appStoreUIServiceMock.Object, _fullTextSearchServiceMock.Object,_imeiCacheServiceMock.Object);
            appStoreMockService.RedisService2 = redisService2;
            redis.FlushAll();

            EntityMapping.Config();
        }