azure 0.0.0 → 0.1.0

data/test/unit/blobs_test.rb

@@ -0,0 +1,156 @@
+require "test_helper"
+require "azure/blobs"
+
+describe Azure::Blobs do
+  let :service do
+    MiniTest::Mock.new
+  end
+
+  describe ".containers" do
+    let :successful_response do
+      double(success?: true, body: Fixtures[:all_containers])
+    end
+
+    it "returns a list of Containers on a successful call" do
+      service.stub(:call, successful_response)
+
+      containers = Azure::Blobs.containers(service)
+      containers.must_include Azure::Blobs::Container.new("container-name")
+    end
+  end
+
+  describe ".create_container" do
+    let :successful_response do
+      double(success?: true)
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "returns a valid container when successful" do
+      service.stub(:call, successful_response)
+
+      container = Azure::Blobs.create_container("mycontainer", {}, Azure::Blobs::Container::PRIVATE, service)
+      container.name.must_equal "mycontainer"
+      assert container.valid?
+    end
+
+    it "returns an invalid container when failed" do
+      service.stub(:call, failed_response)
+
+      container = Azure::Blobs.create_container("mycontainer", {}, Azure::Blobs::Container::PRIVATE, service)
+      container.name.must_be_nil
+      refute container.valid?
+      container.error.must_equal failed_response.error
+    end
+  end
+
+  describe ".delete_container" do
+    let :successful_response do
+      double(success?: true)
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    let :container do
+      Azure::Blobs::Container.new("mycontainer")
+    end
+
+    it "returns true when successful and freezes the container" do
+      service.stub(:call, successful_response)
+
+      result = Azure::Blobs.delete_container(container, service)
+      result.must_equal true
+      assert container.frozen?
+    end
+
+    it "returns false when failed" do
+      service.stub(:call, failed_response)
+
+      result = Azure::Blobs.delete_container(container, service)
+      result.must_equal false
+      container.error.must_equal failed_response.error
+      refute container.frozen?
+      refute container.valid?
+    end
+  end
+
+  describe ".load_container_metadata" do
+    let :successful_response do
+      double(success?: true, headers: headers)
+    end
+
+    let :failed_response do
+      double(success?: false, headers: headers, error: Object.new)
+    end
+
+    let :headers do
+      { "x-ms-meta-Name"    => "FooBar",
+        "x-ms-meta-Version" => "1.0",
+        "ETag"              => "Blah" }
+    end
+
+    let :container do
+      Azure::Blobs::Container.new("mycontainer")
+    end
+
+    it "returns the subset of response headers that start with x-ms-meta- when successful" do
+      service.stub(:call, successful_response)
+
+      metadata = Azure::Blobs.load_container_metadata(container, service)
+      metadata["Name"].must_equal "FooBar"
+      metadata["Version"].must_equal "1.0"
+      metadata.size.must_equal 2
+    end
+
+    it "updates the container's metadata if successful" do
+      service.stub(:call, successful_response)
+
+      Azure::Blobs.load_container_metadata(container, service)
+      container.metadata.must_equal("Name" => "FooBar", "Version" => "1.0")
+    end
+
+    it "invalidates the container on failure" do
+      service.stub(:call, failed_response)
+
+      metadata = Azure::Blobs.load_container_metadata(container, service)
+      metadata.must_equal({})
+      container.metadata.wont_equal headers
+      container.error.must_equal failed_response.error
+      refute container.valid?
+    end
+  end
+
+  describe ".save_container_metadata" do
+    let :successful_response do
+      double(success?: true)
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    let :container do
+      Azure::Blobs::Container.new("mycontainer")
+    end
+
+    it "returns true when successful" do
+      service.stub(:call, successful_response)
+
+      result = Azure::Blobs.save_container_metadata(container, service)
+      result.must_equal true
+    end
+
+    it "invalidates the container and returns false on failure" do
+      service.stub(:call, failed_response)
+
+      result = Azure::Blobs.save_container_metadata(container, service)
+      result.must_equal false
+      container.error.must_equal failed_response.error
+      refute container.valid?
+    end
+  end
+end

data/test/unit/core/service_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+require "azure/core/service"
+
+describe Azure::Core::Service do
+  let :signer do
+    double()
+  end
+
+  let :request do
+    req = MiniTest::Mock.new
+    req.stub(:request!, response)
+    req
+  end
+
+  let :response do
+    double()
+  end
+
+  let :request_factory do
+    rf = MiniTest::Mock.new
+    rf.stub(:new, request)
+    rf
+  end
+
+  let :authorizer do
+    auth = MiniTest::Mock.new
+    auth.stub(:sign)
+    auth
+  end
+
+  subject do
+    Azure::Core::Service.new(signer, authorizer)
+  end
+
+  it "instantiates a new request and signs it" do
+    request_factory.expect(:new, request, [:get, "/", nil])
+    authorizer.expect(:sign, request, [request, signer])
+
+    subject.call(:get, "/", nil, request_factory)
+
+    request_factory.verify
+    authorizer.verify
+  end
+
+  it "returns the response" do
+    resp = subject.call(:get, "/", nil, request_factory)
+    resp.must_equal response
+  end
+
+  it "yields the request before signing it" do
+    subject.call(:get, "/", nil, request_factory) do |req|
+      authorizer.expect(:sign, req, [req, signer])
+    end
+
+    authorizer.verify
+  end
+end

data/test/unit/core/utils/interval_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+require "azure/core/utils/interval"
+
+describe Azure::Core::Utils::Interval do
+  let :described_class do
+    Azure::Core::Utils::Interval
+  end
+
+  describe ".parse" do
+    def self.assert_parses(interval_string, seconds)
+      it "parses #{interval_string.inspect} into #{seconds.inspect}s" do
+        described_class.parse(interval_string).must_equal seconds
+      end
+    end
+
+    assert_parses "P1D",    86400
+    assert_parses "P1DT0S", 86400
+    assert_parses "PT1H",   3600
+    assert_parses "PT1M",   60
+    assert_parses "PT1S",   1
+
+    assert_parses "PT0.12S", 0.12
+
+    assert_parses "P1DT1H1M1S",      90061
+    assert_parses "P8DT3H24M15.12S", 703455.12
+  end
+
+  describe ".try_convert" do
+    it "creates an Interval out of a number" do
+      result = described_class.try_convert(10.5)
+      result.class.must_equal described_class
+      result.must_equal 10.5
+    end
+
+    it "creates an Interval out of a properly formatted string" do
+      result = described_class.try_convert("PT1H")
+      result.class.must_equal described_class
+      result.must_equal 3600
+    end
+
+    it "returns nil if passed a malformed string" do
+      result = described_class.try_convert("WAT?")
+      result.must_be_nil
+    end
+
+    it "returns nil if passed nil" do
+      result = described_class.try_convert(nil)
+      result.must_be_nil
+    end
+  end
+
+  describe "#to_s" do
+    def self.assert_converts(seconds, interval_string)
+      it "converts #{seconds.inspect}s into #{interval_string.inspect}" do
+        described_class.new(seconds).to_s.must_equal interval_string
+      end
+    end
+
+    assert_converts 86400, "P1D"
+    assert_converts 3600,  "PT1H"
+    assert_converts 60,    "PT1M"
+    assert_converts 1,     "PT1S"
+    assert_converts 0,     "PT0S"
+
+    assert_converts 0.12, "PT0.12S"
+
+    assert_converts 90061,    "P1DT1H1M1S"
+    assert_converts 703455.5, "P8DT3H24M15.5S"
+  end
+end

data/test/unit/core/utils/queryable_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'azure/core/utils/queryable'
+
+describe Azure::Core::Utils::Queryable do
+
+  include Azure::Core::Utils::Queryable
+
+  describe "Translating a hash of options" do
+    it "accept :skip" do
+      opts = { :skip => 2 }
+      translate_options_hash(opts).must_equal({ '$skip' => 2 })
+    end
+
+    it "accept :top" do
+      opts = { :top => 3 }
+      translate_options_hash(opts).must_equal({ '$top' => 3 })
+    end
+  end
+
+  describe "Building query strings" do
+    it "should build an empty string" do
+      query = {}
+      build_query(query).must_equal nil
+    end
+
+    it "should accept :select" do
+      query = {
+        :select => ["FirstName", "Email"]
+      }
+      build_query(query).must_equal "$select=FirstName,Email"
+    end
+
+    it "should accept :top" do
+      query = {
+        :top => 5
+      }
+      build_query(query).must_equal "$top=5"
+    end
+
+    it "should accept :filter" do
+      query = {
+        :filter => "FirstName eq 'Alfred'"
+      }
+      build_query(query).must_equal "$filter=FirstName%20eq%20'Alfred'"
+    end
+
+    it "should accept NextTableName" do
+      query = {
+        "NextTableName" => "my_table"
+      }
+      build_query(query).must_equal "NextTableName=my_table"
+    end
+
+    it "should accept NextPartitionKey and NextRowKey" do
+      query = {
+        "NextPartitionKey" => "part1",
+        "NextRowKey" => "row1",
+      }
+      build_query(query).must_equal "NextPartitionKey=part1&NextRowKey=row1"
+    end
+
+    it "should accept :skip" do
+      query = {
+        :skip => 2
+      }
+      build_query(query).must_equal "$skip=2"
+    end
+  end
+end

data/test/unit/core/utils/storage_service_properties_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'azure/core/utils/storage_service_properties'
+
+describe Azure::Core::Utils::StorageServiceProperties do
+  it "convert an option hash to a service properties xml" do
+
+    options = {
+      "Logging" => {
+        "Version" => "1.0",
+        "Delete" => "true",
+        "Read" => "true",
+        "Write" => "true",
+        "RetentionPolicy" => {
+          "Enabled" => true,
+          "Days" => 7
+        }
+      },
+      "Metrics"=> {
+        "Version" => "1.0",
+        "Enabled" => "true",
+        "IncludeAPIs" => "false",
+        "RetentionPolicy" => {
+          "Enabled" => true,
+          "Days" => 7
+        }
+      }
+    }
+
+    xml = Azure::Core::Utils::StorageServiceProperties.hash_to_xml(options)
+
+    (xml / "Logging" / "Version").text.must_equal "1.0"
+    (xml / "Logging" / "Delete").text.must_equal "true"
+    (xml / "Metrics" / "IncludeAPIs").text.must_equal "false"
+    (xml / "Metrics" / "RetentionPolicy" / "Enabled").text.must_equal "true"
+    (xml / "Metrics" / "RetentionPolicy" / "Days").text.must_equal "7"
+  end
+
+  it "should be able to convert from an xml document string to a hash" do
+    xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+      <StorageServiceProperties>
+          <Logging>
+              <Version>version-number</Version>
+              <Delete>true</Delete>
+              <Read>true</Read>
+              <Write>true</Write>
+              <RetentionPolicy>
+                  <Enabled>true</Enabled>
+                  <Days>number-of-days</Days>
+              </RetentionPolicy>
+          </Logging>
+          <Metrics>
+              <Version>version-number</Version>
+              <Enabled>true</Enabled>
+              <IncludeAPIs>true</IncludeAPIs>
+              <RetentionPolicy>
+                  <Enabled>true</Enabled>
+                  <Days>number-of-days</Days>
+              </RetentionPolicy>
+          </Metrics>
+          <DefaultServiceVersion>default-service-version-string</DefaultServiceVersion>
+      </StorageServiceProperties>"
+
+    hash = Azure::Core::Utils::StorageServiceProperties.xml_string_to_hash(xml)
+    hash["Logging"]["Read"].must_equal "true"
+  end
+end

data/test/unit/error_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+require "azure/error"
+
+describe Azure::HTTPError do
+  let :http_response do
+    double(body: Fixtures[:error], code: 409)
+  end
+
+  subject do
+    Azure::HTTPError.new(http_response)
+  end
+
+  it "is an Azure::Error" do
+    subject.must_be_kind_of Azure::Error
+  end
+
+  it "lets us see the errors'status code" do
+    subject.code.must_equal 409
+  end
+
+  it "lets us see the error's type" do
+    subject.type.must_equal "TableAlreadyExists"
+  end
+
+  it "lets us see the error's description" do
+    subject.description.must_equal "The table specified already exists."
+  end
+
+  it "generates an error message that wraps both the type and description" do
+    subject.message.must_equal "TableAlreadyExists (409): The table specified already exists."
+  end
+
+  it "sets the type to unknown if the response body is not an XML" do
+    http_response.body = "\r\nInvalid request\r\n"
+
+    subject.type.must_equal "Unknown"
+    subject.description.must_equal "Invalid request"
+  end
+end