public async Task CreateStaticStorageManifestIncludesAuthHeader()
        {
            var manifestName = "NewManifest";
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            await client.CreateStaticManifest(containerName, manifestName, new Dictionary<string, string>(), content);

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Auth-Token"));
            Assert.AreEqual(this.authId, this.simulator.Headers["X-Auth-Token"]);
        }
        public async Task CreatingStorageObjectMultipleTimesOverwrites()
        {
            var containerName = "newContainer";
            var objectName = "NewObject";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            var resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));
            
            var otherData = "Other data that is longer";
            var otherContent = TestHelper.CreateStream(otherData);

            resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), otherContent);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));

            var objectContent = TestHelper.GetStringFromStream(this.simulator.Objects[objectName].Content);
            Assert.AreEqual(otherData, objectContent);
        }
        public async Task ErrorIsReturnedWhenUpdatingAContainerThatIsNotFound()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var metadata = new Dictionary<string, string> { { "Test1", "Test1" }, { "Test2", "Test2" } };

            var resp = await client.UpdateContainer(containerName, metadata);

            Assert.AreEqual(HttpStatusCode.NotFound, resp.StatusCode);
        }
        public async Task UpdateStorageContainerIncludesAuthHeader()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var metadata = new Dictionary<string, string> { { "Test1", "Test1" }, { "Test2", "Test2" } };

            await client.UpdateContainer(containerName, metadata);

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Auth-Token"));
            Assert.AreEqual(this.authId, this.simulator.Headers["X-Auth-Token"]);
        }
        public async Task CanDeleteStorageContainer()
        {
            var containerName = "newContainer";

            this.simulator.Containers.Add(containerName, new StorageRestSimulator.StorageItem(containerName));

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.DeleteContainer(containerName);

            Assert.AreEqual(HttpStatusCode.NoContent, resp.StatusCode);
            Assert.IsFalse(this.simulator.Containers.ContainsKey(containerName));
        }
        public async Task ErrorIsReturnedWhenDeletingAContainerThatIsNotFound()
        {
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.DeleteContainer(containerName);

            Assert.AreEqual(HttpStatusCode.NotFound, resp.StatusCode);
        }
        public async Task DeleteStorageContainerIncludesAuthHeader()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            await client.DeleteContainer(containerName);

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Auth-Token"));
            Assert.AreEqual(this.authId, this.simulator.Headers["X-Auth-Token"]);
        }
        public async Task TryingToCreateAnObjectAndCancelThrowsException()
        {
            var objectName = "NewObject";
            var containerName = "newContainer";
            var token = new CancellationToken(true);
            this.simulator.Delay = TimeSpan.FromMilliseconds(500);

            var client =
                new StorageServiceRestClient(GetValidContext(token), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            try
            {
                await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);
            }
            catch (Exception ex)
            {
                Assert.IsInstanceOfType(ex,typeof(OperationCanceledException));
                Assert.IsFalse(this.simulator.Objects.ContainsKey(objectName));
            }
        }
        public async Task CanCreateStorageContainer()
        {
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.CreateContainer(containerName, new Dictionary<string, string>());

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Containers.ContainsKey(containerName));
        }
        public async Task CreateStorageObjectWithNullContent()
        {
            var objectName = "NewObject/////";
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), null);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));
        }
        public async Task TryingToCreateAnObjectWithBadAuthenticationFails()
        {
            var authId = "54321";
            var objectName = "NewObject";
            var containerName = "newContainer";

            var context = GetValidContext();
            context.Credential.SetAccessTokenId(authId);
            var client =
                new StorageServiceRestClient(context, this.ServiceLocator);

            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            var resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);

            Assert.AreEqual(HttpStatusCode.Unauthorized, resp.StatusCode);
            Assert.IsFalse(this.simulator.Objects.ContainsKey(objectName));
        }
        public async Task CreateStorageObjectWithForwardSlashesInName()
        {
            var objectName = "New/Object";
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            var resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);

            Assert.AreEqual(string.Format("{0}/{1}/{2}", this.endpoint, containerName, objectName), this.simulator.Uri.ToString());

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));

            var objectContent = TestHelper.GetStringFromStream(this.simulator.Objects[objectName].Content);
            Assert.AreEqual(data, objectContent);
        }
        public async Task CanCreateStorageObjectWithMetaData()
        {
            var objectName = "NewObject";
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            var metaData = new Dictionary<string, string> {{"Test1", "Test1"}, {"Test2", "Test2"}};

            var resp = await client.CreateObject(containerName, objectName, metaData, content);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Object-Meta-Test1"));
            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Object-Meta-Test2"));
            Assert.AreEqual("Test1", this.simulator.Headers["X-Object-Meta-Test1"]);
            Assert.AreEqual("Test2", this.simulator.Headers["X-Object-Meta-Test2"]);

            var objectContent = TestHelper.GetStringFromStream(this.simulator.Objects[objectName].Content);
            Assert.AreEqual(data, objectContent);
        }
        public async Task CreatedStorageObjectHasETag()
        {
            var objectName = "NewObject";
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);
            var hash = Convert.ToBase64String(MD5.Create().ComputeHash(content));
            content.Position = 0;

            var resp = await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);

            Assert.IsTrue(resp.Headers.Any(kvp => kvp.Key == "ETag"));
            Assert.AreEqual(hash, resp.Headers.First(kvp => kvp.Key == "ETag").Value.First());

            Assert.IsTrue(this.simulator.Objects.ContainsKey(objectName));

            var objectContent = TestHelper.GetStringFromStream(this.simulator.Objects[objectName].Content);
            Assert.AreEqual(data, objectContent);
        }
        public async Task CanGetStorageObject()
        {
            var containerName = "newContainer";
            var objectName = "newObject";
            var data = "Some Data";

            var content = TestHelper.CreateStream(data);
            var hash = Convert.ToBase64String(MD5.Create().ComputeHash(content));
            content.Position = 0;

            this.simulator.Objects.Add(objectName, new StorageRestSimulator.StorageItem(objectName) { Content = content });

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.GetObject(containerName, objectName);

            Assert.AreEqual(HttpStatusCode.OK, resp.StatusCode);

            var respContent = TestHelper.GetStringFromStream(resp.Content);
            Assert.AreEqual(data, respContent);

            Assert.IsTrue(resp.Headers.Any(kvp => kvp.Key == "ETag"));
            Assert.AreEqual(hash, resp.Headers.First(kvp => kvp.Key == "ETag").Value.First());
        }
        public async Task CreateStorageConainerWithSlashesInContainerName()
        {
            var containerName = "new/Container";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            await client.CreateContainer(containerName, new Dictionary<string, string>());
        }
        public async Task CanGetStorageObjectWithMetadata()
        {
            var containerName = "newContainer";
            var objectName = "newObject";
            var data = "Some Data";

            var content = TestHelper.CreateStream(data);

            var metaData = new Dictionary<string, string> { { "X-Object-Meta-Test1", "Test1" }, { "X-Object-Meta-Test2", "Test2" }};

            this.simulator.Objects.Add(objectName, new StorageRestSimulator.StorageItem(objectName) { MetaData = metaData, Content = content});

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.GetObject(containerName, objectName);

            Assert.AreEqual(HttpStatusCode.OK, resp.StatusCode);

            Assert.IsTrue(resp.Headers.Any(kvp => kvp.Key == "X-Object-Meta-Test2"));
            Assert.AreEqual("Test2", resp.Headers.First(kvp => kvp.Key == "X-Object-Meta-Test2").Value.First());

            var respContent = TestHelper.GetStringFromStream(resp.Content);
            Assert.AreEqual(data,respContent);
        }
        public async Task CanCreateStorageContainerWithMetaData()
        {
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            
            var metaData = new Dictionary<string, string> { { "Test1", "Test1" }, { "Test2", "Test2" } };

            var resp = await client.CreateContainer(containerName, metaData);

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Containers.ContainsKey(containerName));

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Container-Meta-Test1"));
            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Container-Meta-Test2"));
            Assert.AreEqual("Test1", this.simulator.Headers["X-Container-Meta-Test1"]);
            Assert.AreEqual("Test2", this.simulator.Headers["X-Container-Meta-Test2"]);
        }
        public async Task CanDeleteStorageObject()
        {
            var containerName = "newContainer";
            var objectName = "newObject";
            var data = "Some Data";

            var content = TestHelper.CreateStream(data);

            this.simulator.Objects.Add(objectName, new StorageRestSimulator.StorageItem(objectName) {Content = content});

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.DeleteObject(containerName, objectName);

            Assert.AreEqual(HttpStatusCode.NoContent, resp.StatusCode);
            Assert.IsFalse(this.simulator.Objects.ContainsKey(objectName));
        }
        public async Task CreatingStorageContainerMultipleTimesOverwrites()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.CreateContainer(containerName, new Dictionary<string, string>());

            Assert.AreEqual(HttpStatusCode.Created, resp.StatusCode);
            Assert.IsTrue(this.simulator.Containers.ContainsKey(containerName));

            var metaData = new Dictionary<string, string> { { "Test1", "Test1" }, { "Test2", "Test2" } };

            resp = await client.CreateContainer(containerName, metaData);

            Assert.AreEqual(HttpStatusCode.Accepted, resp.StatusCode);
            Assert.IsTrue(this.simulator.Containers.ContainsKey(containerName));
            Assert.IsTrue(this.simulator.Containers[containerName].MetaData.ContainsKey("X-Container-Meta-Test1"));
        }
        public async Task DeleteStorageContainerFormsCorrectUrlAndMethod()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            await client.DeleteContainer(containerName);

            Assert.AreEqual(string.Format("{0}/{1}", endpoint, containerName), this.simulator.Uri.ToString());
            Assert.AreEqual(HttpMethod.Delete, this.simulator.Method);
        }
        public async Task ErrorIsReturnedWhenContainerIsNotFound()
        {
            var containerName = "newContainer";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.GetContainer(containerName);

            Assert.AreEqual(HttpStatusCode.NotFound, resp.StatusCode);

            //Add some assert here to validate that we got all the headers we expected... 
        }
        public async Task ErrorIsReturnedWhenDeletingAContainerThatIsNotEmpty()
        {
            var containerName = "newContainer";

            this.simulator.Containers.Add(containerName, new StorageRestSimulator.StorageItem(containerName));
            this.simulator.IsContainerEmpty = false;

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.DeleteContainer(containerName);

            Assert.AreEqual(HttpStatusCode.Conflict, resp.StatusCode);
            Assert.IsTrue(this.simulator.Containers.ContainsKey(containerName));
        }
        public async Task CanGetStorageContainer()
        {
            var containerName = "newContainer";

            this.simulator.Containers.Add(containerName, new StorageRestSimulator.StorageItem(containerName));

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.GetContainer(containerName);

            Assert.AreEqual(HttpStatusCode.OK, resp.StatusCode);

            //Add some assert here to validate that we got all the headers we expected... 
        }
        public async Task CreateDynamicStorageManifestIncludesAuthHeader()
        {
            var manifestName = "NewManifest";
            var segPath = "blah/blah";
            var containerName = "newContainer";

            var client = new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            await client.CreateDynamicManifest(containerName, manifestName, new Dictionary<string, string>(), segPath);

            Assert.IsTrue(this.simulator.Headers.ContainsKey("X-Auth-Token"));
            Assert.AreEqual(this.authId, this.simulator.Headers["X-Auth-Token"]);
        }
        public async Task GetStorageObjectFormsCorrectUrlAndMethod()
        {
            var containerName = "newContainer";
            var objectName = "newObject";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            await client.GetObject(containerName, objectName);

            Assert.AreEqual(string.Format("{0}/{1}/{2}", endpoint, containerName, objectName), this.simulator.Uri.ToString());
            Assert.AreEqual(HttpMethod.Get, this.simulator.Method);
        }
        public async Task UpdateStorageContainerFormsCorrectUrlAndMethod()
        {
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var metadata = new Dictionary<string, string> { { "Test1", "Test1" }, { "Test2", "Test2" } };

            await client.UpdateContainer(containerName, metadata);

            Assert.AreEqual(string.Format("{0}/{1}", endpoint, containerName), this.simulator.Uri.ToString());
            Assert.AreEqual(HttpMethod.Post, this.simulator.Method);
        }
        public async Task ErrorIsReturnedWhenObjectIsNotFound()
        {
            var containerName = "newContainer";
            var objectName = "newObject";

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var resp = await client.GetObject(containerName, objectName);

            Assert.AreEqual(HttpStatusCode.NotFound, resp.StatusCode);
        }
        public async Task CanUpdateAStorageContainer()
        {
            var containerName = "newContainer";

            var origMetaData = new Dictionary<string, string> { { "X-Container-Meta-Test1", "Test1" } };

            this.simulator.Containers.Add(containerName, new StorageRestSimulator.StorageItem(containerName) { MetaData = origMetaData });

            var client =
                 new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);

            var metadata = new Dictionary<string, string> { { "Test2", "Test2" } };

            var resp = await client.UpdateContainer(containerName, metadata);
            Assert.AreEqual(HttpStatusCode.Accepted, resp.StatusCode);

            resp = await client.GetContainer(containerName);
            
            Assert.IsTrue(resp.Headers.Any(kvp => kvp.Key == "X-Container-Meta-Test2"));
            Assert.IsFalse(resp.Headers.Any(kvp => kvp.Key == "X-Container-Meta-Test1"));
            Assert.AreEqual("Test2", resp.Headers.First(kvp => kvp.Key == "X-Container-Meta-Test2").Value.First());
        }
        public async Task CreateStorageObjectFormsCorrectUrlAndMethod()
        {
            var objectName = "NewObject";
            var containerName = "newContainer";

            var client =
                new StorageServiceRestClient(GetValidContext(), this.ServiceLocator);
            var data = "Some random data";
            var content = TestHelper.CreateStream(data);

            await client.CreateObject(containerName, objectName, new Dictionary<string, string>(), content);

            Assert.AreEqual(string.Format("{0}/{1}/{2}", endpoint, containerName, objectName), this.simulator.Uri.ToString());
            Assert.AreEqual(HttpMethod.Put, this.simulator.Method);
        }