public void CanParseContainerWithValidJsonPayloadAndHeaders()
        {
            var containerName   = "TestContainer";
            var validObjectJson = @"[
                                            {
                                                ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                                ""last_modified"": ""2014-03-07T21:31:31.588170"",
                                                ""bytes"": 0,
                                                ""name"": ""BLAH"",
                                                ""content_type"": ""application/octet-stream""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());
            var headers   = new HttpHeadersAbstraction
            {
                { "X-Container-Bytes-Used", "12345" },
                { "X-Container-Object-Count", "1" }
            };

            var container = converter.Convert(containerName, headers, validObjectJson);

            Assert.IsNotNull(container);
            Assert.AreEqual(containerName, container.Name);
            Assert.AreEqual(12345, container.TotalBytesUsed);
            Assert.AreEqual(1, container.TotalObjectCount);
            Assert.AreEqual(1, container.Objects.ToList().Count());
        }
        public void CanParseValidJsonPayloadWithMultipleObjects()
        {
            var validMultipleContainerJson = @"[
                                            {
                                                  ""count"": 1,
                                                  ""bytes"": 7,
                                                  ""name"": ""TestContainer""
                                            },
                                            {
                                                  ""count"": 5,
                                                  ""bytes"": 2000,
                                                  ""name"": ""OtherTestContainer""
                                            }
                                           ]";

            var converter  = new StorageContainerPayloadConverter(new ServiceLocator());
            var containers = converter.Convert(validMultipleContainerJson).ToList();

            Assert.AreEqual(2, containers.Count());
            var obj1 =
                containers.First(o => string.Equals(o.Name, "TestContainer", StringComparison.InvariantCultureIgnoreCase));
            var obj2 =
                containers.First(o => string.Equals(o.Name, "OtherTestContainer", StringComparison.InvariantCultureIgnoreCase));

            Assert.IsNotNull(obj1);
            Assert.IsNotNull(obj2);

            Assert.AreEqual(7, obj1.TotalBytesUsed);
            Assert.AreEqual("TestContainer", obj1.Name);
            Assert.AreEqual(1, obj1.TotalObjectCount);

            Assert.AreEqual(2000, obj2.TotalBytesUsed);
            Assert.AreEqual("OtherTestContainer", obj2.Name);
            Assert.AreEqual(5, obj2.TotalObjectCount);
        }
        public void CanParseValidEmptyJsonArrayPayload()
        {
            var emptyJsonArray = @"[]";

            var converter  = new StorageContainerPayloadConverter(new ServiceLocator());
            var containers = converter.Convert(emptyJsonArray).ToList();

            Assert.AreEqual(0, containers.Count());
        }
        public void CanParseAnEmptyPayload()
        {
            var payload = string.Empty;

            var converter  = new StorageContainerPayloadConverter(new ServiceLocator());
            var containers = converter.Convert(payload).ToList();

            Assert.AreEqual(0, containers.Count());
        }
        public void CannotParseContainerWithNullPayload()
        {
            var converter = new StorageContainerPayloadConverter(new ServiceLocator());
            var headers   = new HttpHeadersAbstraction
            {
                { "X-Container-Bytes-Used", "12345" },
                { "X-Container-Object-Count", "1" }
            };

            converter.Convert("Name", headers, null);
        }
        public void CannotParseJsonPayloadWithMissingNameProperty()
        {
            string InvalidJsonWithoutName = @"[
                                            {
                                                  ""count"": 1,
                                                  ""bytes"": 7
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert(InvalidJsonWithoutName);
        }
        public void CannotParseJsonPayloadWithMissingCountProperty()
        {
            string InvalidJsonWithoutCount = @"[
                                            {
                                                  ""bytes"": 7,
                                                  ""name"": ""TestContainer""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert(InvalidJsonWithoutCount);
        }
        public void CannotParseJsonPayloadWithMissingBytesProperty()
        {
            var InvalidJsonWithoutBytes = @"[
                                            {
                                                  ""count"": 1,
                                                  ""name"": ""TestContainer""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert(InvalidJsonWithoutBytes);
        }
        public void CannotParseJsonPayloadWithBadCountValue()
        {
            string InvalidJsonWithBadCountValue = @"[
                                            {
                                                  ""count"": ""NOT A NUMBER"",
                                                  ""bytes"": 12345,
                                                  ""name"": ""TestContainer""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert(InvalidJsonWithBadCountValue);
        }
        public void CannotParseContainerWithNullHeaders()
        {
            var validObjectJson = @"[
                                            {
                                                ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                                ""last_modified"": ""2014-03-07T21:31:31.588170"",
                                                ""bytes"": 0,
                                                ""name"": ""BLAH"",
                                                ""content_type"": ""application/octet-stream""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert("Name", null, validObjectJson);
        }
        public void CannotParseContainerWithBadPayload()
        {
            var containerName   = "TestContainer";
            var validObjectJson = @"[
                                            {
                                                ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                                ""last_modified"":";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());
            var headers   = new HttpHeadersAbstraction
            {
                { "X-Container-Bytes-Used", "12345" },
                { "X-Container-Object-Count", "1" }
            };

            converter.Convert(containerName, headers, validObjectJson);
        }
        public void CannotParseContainerWithNullName()
        {
            var validObjectJson = @"[
                                            {
                                                ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                                ""last_modified"": ""2014-03-07T21:31:31.588170"",
                                                ""bytes"": 0,
                                                ""name"": ""BLAH"",
                                                ""content_type"": ""application/octet-stream""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());
            var headers   = new HttpHeadersAbstraction
            {
                { "X-Container-Bytes-Used", "12345" },
                { "X-Container-Object-Count", "1" }
            };

            converter.Convert(null, headers, validObjectJson);
        }
        public void ParseExceptionIncludesNameWhenPossible()
        {
            string InvalidJsonWithoutBytes = @"[
                                            {
                                                  ""count"": 1,
                                                  ""name"": ""TestContainer""
                                            }]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            try
            {
                converter.Convert(InvalidJsonWithoutBytes);
                Assert.Fail("Parsing did not fail as expected.");
            }
            catch (FormatException ex)
            {
                Assert.IsTrue(ex.Message.StartsWith("Storage Container 'TestContainer'"));
            }
        }
        public void CannotParseInvalidJsonPayload()
        {
            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert("[ { \"SomeAtrib\" }]");
        }
        public void CanParseContainerWithValidJsonPayloadWithNestedFoldersAndObjects()
        {
            var containerName   = "TestContainer";
            var validObjectJson = @"[
                                        {
                                            ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                            ""last_modified"": ""2014-03-27T20:57:11.150910"",
                                            ""bytes"": 0,
                                            ""name"": ""a/"",
                                            ""content_type"": ""application/octet-stream""
                                        },
                                        {
                                            ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                            ""last_modified"": ""2014-03-27T20:57:36.676350"",
                                            ""bytes"": 0,
                                            ""name"": ""a/b/"",
                                            ""content_type"": ""application/octet-stream""
                                        },
                                        {
                                            ""hash"": ""437b930db84b8079c2dd804a71936b5f"",
                                            ""last_modified"": ""2014-03-27T20:58:36.676620"",
                                            ""bytes"": 9,
                                            ""name"": ""a/b/b"",
                                            ""content_type"": ""text/plain;charset=UTF-8""
                                        },
                                        {
                                            ""hash"": ""437b930db84b8079c2dd804a71936b5f"",
                                            ""last_modified"": ""2014-03-27T20:58:43.935540"",
                                            ""bytes"": 9,
                                            ""name"": ""a/b/c"",
                                            ""content_type"": ""text/plain;charset=UTF-8""
                                        },
                                        {
                                            ""hash"": ""437b930db84b8079c2dd804a71936b5f"",
                                            ""last_modified"": ""2014-03-27T20:58:54.142580"",
                                            ""bytes"": 9,
                                            ""name"": ""a/b/c/object3"",
                                            ""content_type"": ""text/plain;charset=UTF-8""
                                        },
                                        {
                                            ""hash"": ""437b930db84b8079c2dd804a71936b5f"",
                                            ""last_modified"": ""2014-03-27T20:58:25.771530"",
                                            ""bytes"": 9,
                                            ""name"": ""a/object2"",
                                            ""content_type"": ""text/plain;charset=UTF-8""
                                        },
                                        {
                                            ""hash"": ""d41d8cd98f00b204e9800998ecf8427e"",
                                            ""last_modified"": ""2014-03-27T20:57:47.122360"",
                                            ""bytes"": 0,
                                            ""name"": ""a/x/"",
                                            ""content_type"": ""application/octet-stream""
                                        },
                                        {
                                            ""hash"": ""437b930db84b8079c2dd804a71936b5f"",
                                            ""last_modified"": ""2014-03-27T20:58:15.696360"",
                                            ""bytes"": 9,
                                            ""name"": ""object1"",
                                            ""content_type"": ""text/plain;charset=UTF-8""
                                        }
                                    ]";

            var converter = new StorageContainerPayloadConverter(new ServiceLocator());
            var headers   = new HttpHeadersAbstraction
            {
                { "X-Container-Bytes-Used", "45" },
                { "X-Container-Object-Count", "8" }
            };

            var container = converter.Convert(containerName, headers, validObjectJson);

            Assert.IsNotNull(container);
            Assert.AreEqual(containerName, container.Name);
            Assert.AreEqual(45, container.TotalBytesUsed);
            Assert.AreEqual(8, container.TotalObjectCount);
            Assert.AreEqual(8, container.Objects.ToList().Count());
            Assert.IsTrue(container.Objects.ToList().Any(o => o.Name == "object1"));

            var folders = container.Folders.ToList();

            Assert.AreEqual(1, folders.Count());

            var aNode = folders.First();

            Assert.AreEqual("a", aNode.Name);
            Assert.AreEqual(2, aNode.Folders.Count);
            Assert.AreEqual(1, aNode.Objects.Count);
            Assert.IsTrue(aNode.Objects.Any(f => f.FullName == "a/object2"));

            var xNode = aNode.Folders.First(f => f.Name == "x");

            Assert.AreEqual(0, xNode.Folders.Count);
            Assert.AreEqual(0, xNode.Objects.Count);

            var bNode = aNode.Folders.First(f => f.Name == "b");

            Assert.AreEqual(1, bNode.Folders.Count);
            Assert.AreEqual(2, bNode.Objects.Count);
            Assert.IsTrue(bNode.Folders.Any(f => f.Name == "c"));
            Assert.IsTrue(bNode.Objects.Any(f => f.FullName == "a/b/c"));
            Assert.IsTrue(bNode.Objects.Any(f => f.FullName == "a/b/b"));

            var cNode = bNode.Folders.First(f => f.Name == "c");

            Assert.AreEqual(0, cNode.Folders.Count);
            Assert.AreEqual(1, cNode.Objects.Count);
            Assert.IsTrue(cNode.Objects.Any(f => f.FullName == "a/b/c/object3"));
        }
        public void CannotParseInvalidPayload()
        {
            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert("NOT JSON");
        }
        public void CannotParseANullPayload()
        {
            var converter = new StorageContainerPayloadConverter(new ServiceLocator());

            converter.Convert(null);
        }