azure 0.0.0 → 0.1.0

data/test/unit/tables/auth/shared_key_lite_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+require "azure/tables/auth/shared_key_lite"
+
+describe Azure::Tables::Auth::SharedKeyLite do
+  subject do
+    Azure::Tables::Auth::SharedKeyLite.new(
+      "account-name",
+      Base64.strict_encode64("access-key")
+    )
+  end
+
+  it "#signable_string includes the relevant bits" do
+    string = subject.signable_string(:get, double(path: "/path"), {
+      "Date" => "Time"
+    })
+
+    string.must_equal "Time\n/account-name/path"
+  end
+
+  it "#signable_string requires a Date or x-ms-date header" do
+    proc {
+      subject.signable_string(:get, double(path: "/path"), {})
+    }.must_raise KeyError, "Headers must include Date"
+  end
+
+  it "#sign will return a Base64-encoded, HMAC/SHA256-encrypted version of the signable string" do
+    def subject.signable_string(*)
+      "TestString"
+    end
+
+    expected = Base64.strict_encode64(
+      OpenSSL::HMAC.digest("sha256", "access-key", "TestString")
+    )
+
+    actual = subject.sign(MiniTest::Mock.new, MiniTest::Mock.new, MiniTest::Mock.new)
+
+    actual.must_equal expected
+  end
+end

data/test/unit/tables/auth/shared_key_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+require "azure/tables/auth/shared_key"
+
+describe Azure::Tables::Auth::SharedKey do
+
+  subject do
+    Azure::Tables::Auth::SharedKey.new(
+      "account-name",
+      Base64.strict_encode64("access-key")
+    )
+  end
+
+  it "#signable_string includes the relevant bits" do
+    string = subject.signable_string(:get, double(path: "/path"), {
+      "Content-MD5"  => "Foo",
+      "Content-Type" => "text/plain",
+      "Date"         => "Time"
+    })
+
+    string.must_equal "GET\nFoo\ntext/plain\nTime\n/account-name/path"
+  end
+
+  it "#signable_string requires a Date or x-ms-date header" do
+    proc {
+      subject.signable_string(:get, double(path: "/path"), {
+        "Content-MD5"  => "Foo",
+        "Content-Type" => "text/plain"
+      })
+    }.must_raise KeyError, "Headers must include Date"
+  end
+
+  it "#sign will return a Base64-encoded, HMAC/SHA256-encrypted version of the signable string" do
+    def subject.signable_string(*)
+      "TestString"
+    end
+
+    expected = Base64.strict_encode64(
+      OpenSSL::HMAC.digest("sha256", "access-key", "TestString")
+    )
+
+    actual = subject.sign(MiniTest::Mock.new, MiniTest::Mock.new, MiniTest::Mock.new)
+
+    actual.must_equal expected
+  end
+end

data/test/unit/tables/entities_collection_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+require "azure/atom"
+require "azure/tables"
+require "azure/tables/entities_collection"
+
+describe Azure::Tables::EntitiesCollection do
+
+  let :service do
+    MiniTest::Mock.new
+  end
+
+  before do
+    @table = Azure::Tables::Table.new("table_name")
+    entries = Azure::Atom::Feed.load_feed(Fixtures[:query_entities_response]).entries
+    @collection = Azure::Tables::EntitiesCollection.from_entries(@table, entries, {}, service)
+  end
+
+  it "return an instance from entries feed" do
+    @collection.must_be :kind_of?, Azure::Tables::EntitiesCollection
+    @collection.size.must_equal 2
+  end
+
+  it "should indicate if the result is a paginated result" do
+    @collection.paginated?.must_equal false
+    @collection.continuation_token("part1", "row2")
+    @collection.paginated?.must_equal true
+  end
+
+  it "should be able to set continuation tokens" do
+    @collection.continuation_token("part1", "row2")
+
+    service.expect(:query_entities, nil, [@table, {
+      "NextPartitionKey" => "part1",
+      "NextRowKey" => "row2"
+    }])
+
+    @collection.next
+  end
+end

data/test/unit/tables/entity_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+require 'azure/tables/entity'
+
+describe Azure::Tables::Entity do
+  before do
+    @entry = Azure::Atom::Entry.load_entry(Fixtures[:insert_entity_response_entry])
+  end
+
+  it "should be able to instantiate an entity from an xml entry" do
+    entity = Azure::Tables::Entity.from_entry(@entry)
+
+    "Mountain View".must_equal entity["Address"]
+    entity["Address"].must_be :kind_of?, String
+  end
+
+  it "should be able to read/write an attribute directly" do
+    entity = Azure::Tables::Entity.new
+    entity["myField"] = "Mine"
+    entity["myField"].must_equal "Mine"
+  end
+
+  it "can reset it's attributes" do
+    source = Azure::Tables::Entity.new("Foo" => "Bar") do |e|
+      e.url = URI("http://localhost/foo")
+    end
+
+    target = Azure::Tables::Entity.new("Baz" => "Qux") do |e|
+      e.url = URI("http://localhost/bar")
+    end
+
+    target.reset(source)
+    target.url.must_equal source.url
+    target.attributes.must_equal source.attributes
+  end
+
+  it "should be able to update itself" do
+    entity, service = entity("Foo" => "Bar")
+    service.expect(:update_entity, true, [entity, { "Foo" => "Qux" }])
+    entity.update("Foo" => "Qux")
+    service.verify
+  end
+
+  it "should be able to merge properties" do
+    entity, service = entity("Foo" => "Bar")
+    service.expect(:merge_entity, true, [entity, { "Baz" => "Qux" }])
+    entity.merge("Baz" => "Qux")
+    service.verify
+  end
+
+  it "should be able to delete itself" do
+    entity, service = entity({})
+    service.expect(:delete_entity, true, [entity])
+    entity.delete.must_equal true
+    service.verify
+  end
+
+  it "can set/get the etag" do
+    entity_1 = Azure::Tables::Entity.new
+    entity_1.etag = "FooBar"
+    entity_1.etag.must_equal "FooBar"
+
+    entity_2 = Azure::Tables::Entity.new
+    entity_2.etag.must_equal "*"
+  end
+
+  def entity(attributes)
+    service = MiniTest::Mock.new
+    uri = URI("http://localhost/foo")
+    entity = Azure::Tables::Entity.new(attributes, service) { |e| e.url = uri }
+    [entity, service]
+  end
+end

data/test/unit/tables/table_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+require "azure/tables/table"
+
+describe Azure::Tables::Table do
+  def entry
+    Atom::Entry.load_entry(Fixtures[:create_table_response_entry])
+  end
+
+  it "can be instantiated from an entry" do
+    table = Azure::Tables::Table.from_entry(entry)
+    table.name.must_equal "mytable"
+    table.url.must_equal URI("http://myaccount.table.core.windows.net/Tables('mytable')")
+  end
+
+  it "is equal to another table if they share the same name" do
+    table_1 = Azure::Tables::Table.new("mytable", URI("http://myaccount.table.core.windows.net/Tables('mytable')"))
+    table_2 = Azure::Tables::Table.new("mytable", URI("http://localhost/foo"))
+
+    table_1.must_equal table_2
+  end
+
+  it "can delete itself" do
+    table, service = table("mytable")
+    service.expect(:delete, true, [table])
+    table.delete.must_equal true
+    service.verify
+  end
+
+  it "can insert an entity" do
+    table, service = table("mytable")
+    entity = Azure::Tables::Entity.new
+    service.expect(:insert_entity, entity, [table, entity])
+    table.insert(entity)
+    service.verify
+  end
+
+  it "can query for a list of entities by not specifying the partition/row keys" do
+    table, service = table("mytable")
+    service.expect(:query_entities, [], [table, {}])
+    table.entities.must_be_empty
+    service.verify
+  end
+
+  it "can query for a specific entity" do
+    table, service = table("mytable")
+    service.expect(:query_entity, nil, [table, "Foo", "Bar", {}])
+    table.entities(partition_key: "Foo", row_key: "Bar").must_be_nil
+    service.verify
+  end
+
+  def table(name)
+    service = MiniTest::Mock.new
+    uri = URI("http://localhost/foo")
+    table = Azure::Tables::Table.new(name, uri, service)
+    [table, service]
+  end
+end

data/test/unit/tables_test.rb

@@ -0,0 +1,302 @@
+require "test_helper"
+require "azure/tables"
+
+describe Azure::Tables do
+  class StubResponse
+    attr_reader :success, :body, :error
+    alias_method :success?, :success
+
+    def initialize(attrs={})
+      @success = attrs.fetch(:success, true)
+      @body = attrs.fetch(:body, nil)
+      @etag = attrs.fetch(:etag, nil)
+      @error = attrs.fetch(:error, nil)
+    end
+
+    def headers
+      { "etag" => @etag }
+    end
+  end
+
+  let :service do
+    MiniTest::Mock.new
+  end
+
+  describe ".all" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:all_tables])
+    end
+
+    it "returns a list of Tables on a successful call" do
+      service.stub(:call, successful_response)
+
+      tables = Azure::Tables.all({}, service)
+      tables.must_include Azure::Tables::Table.new("mytable", nil)
+    end
+  end
+
+  describe ".create" do
+    let :successful_response do
+      double(success?: true, body: Fixtures[:create_table_response_entry])
+    end
+
+    let :failed_response do
+      double(success?: false, body: Fixtures[:error], error: Object.new)
+    end
+
+    it "returns a valid table when successful" do
+      service.stub(:call, successful_response)
+
+      table = Azure::Tables.create("mytable", service)
+      assert table.valid?
+    end
+
+    it "returns an invalid table when unsuccessful" do
+      service.stub(:call, failed_response)
+
+      table = Azure::Tables.create("mytable", service)
+      refute table.valid?
+      table.error.must_equal failed_response.error
+    end
+  end
+
+  describe ".delete" do
+    let :successful_response do
+      double(success?: true)
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "returns true when successful" do
+      table = Azure::Tables::Table.new("mytable", URI("http://localhost/foo"))
+      service.stub(:call, successful_response)
+
+      result = Azure::Tables.delete(table, service)
+      result.must_equal true
+    end
+
+    it "returns false when failed" do
+      table = Azure::Tables::Table.new("mytable", URI("http://localhost/foo"))
+      service.stub(:call, failed_response)
+
+      result = Azure::Tables.delete(table, service)
+      result.must_equal false
+      refute table.valid?
+      table.error.must_equal failed_response.error
+    end
+  end
+
+  describe ".insert_entity" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:insert_entity_response_entry], etag: "Foo")
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "returns the entity when successful" do
+      table = Azure::Tables::Table.new("mytable")
+      entity = Azure::Tables::Entity.new
+
+      service.stub(:call, successful_response)
+
+      Azure::Tables.insert_entity(table, entity, service)
+      entity.etag.must_equal "Foo"
+      entity["Address"].to_s.must_equal "Mountain View"
+    end
+
+    it "adds an error to the entity when unsusccessful" do
+      table = Azure::Tables::Table.new("mytable")
+      entity = Azure::Tables::Entity.new
+
+      service.stub(:call, failed_response)
+
+      Azure::Tables.insert_entity(table, entity, service)
+      entity.etag.must_equal Azure::Tables::Entity::FORCE_UPDATE
+      entity.error.must_equal failed_response.error
+    end
+  end
+
+  describe ".update_entity" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:insert_entity_response_entry], etag: "Foo")
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "replaces the entity's attributes if successful" do
+      entity = Azure::Tables::Entity.new
+      attrs = { "Foo" => "Bar", "Baz" => "Qux" }
+
+      service.stub(:call, successful_response)
+
+      Azure::Tables.update_entity(entity, attrs, false, service)
+      entity.attributes.must_equal attrs
+      entity.etag.must_equal successful_response.headers["etag"]
+      assert entity.valid?
+    end
+
+    it "doesn't change the entity if failed" do
+      entity = Azure::Tables::Entity.new
+      attrs = { "Foo" => "Bar" }
+
+      service.stub(:call, failed_response)
+
+      Azure::Tables.update_entity(entity, attrs, false, service)
+      entity.attributes.wont_equal attrs
+      entity.etag.wont_equal successful_response.headers["etag"]
+      entity.error.must_equal failed_response.error
+      refute entity.valid?
+    end
+  end
+
+  describe ".merge_entity" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:insert_entity_response_entry], etag: "Foo")
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "updates the entity's attributes if successful" do
+      entity = Azure::Tables::Entity.new("Qux" => "Bar")
+      attrs = { "Foo" => "Bar", "Baz" => "Qux" }
+
+      service.stub(:call, successful_response)
+
+      Azure::Tables.merge_entity(entity, attrs, false, service)
+      entity["Qux"].must_equal "Bar"
+      entity["Foo"].must_equal "Bar"
+      entity["Baz"].must_equal "Qux"
+      entity.etag.must_equal successful_response.headers["etag"]
+      assert entity.valid?
+    end
+
+    it "doesn't change the entity if failed" do
+      entity = Azure::Tables::Entity.new("Qux" => "Bar")
+      attrs = { "Foo" => "Bar", "Baz" => "Qux" }
+
+      service.stub(:call, failed_response)
+
+      Azure::Tables.merge_entity(entity, attrs, false, service)
+      entity.attributes.must_equal({ "Qux" => "Bar" })
+      entity.etag.wont_equal successful_response.headers["etag"]
+      entity.error.must_equal failed_response.error
+      refute entity.valid?
+    end
+  end
+
+  describe ".delete_entity" do
+    let :successful_response do
+      StubResponse.new(success: true, etag: "Foo")
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "freezes the entity if successful" do
+      entity = Azure::Tables::Entity.new("Qux" => "Bar")
+
+      service.stub(:call, successful_response)
+
+      Azure::Tables.delete_entity(entity, false, service)
+      entity.etag.must_equal successful_response.headers["etag"]
+      assert entity.frozen?
+      assert entity.valid?
+    end
+
+    it "sets the error on the entity if failed" do
+      entity = Azure::Tables::Entity.new("Qux" => "Bar")
+
+      service.stub(:call, failed_response)
+
+      Azure::Tables.delete_entity(entity, false, service)
+      entity.etag.wont_equal successful_response.headers["etag"]
+      entity.error.must_equal failed_response.error
+      refute entity.frozen?
+      refute entity.valid?
+    end
+  end
+
+  describe ".query_entities" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:query_entities_response])
+    end
+
+    let :empty_response do
+      StubResponse.new(success: true, body: Fixtures[:query_entities_empty_response])
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "returns a list of entities when successful" do
+      table = Azure::Tables::Table.new("mytable")
+
+      service.stub(:call, successful_response)
+
+      entities = Azure::Tables.query_entities(table, {}, service)
+      entities.must_be :kind_of?, Azure::Tables::EntitiesCollection
+      entities.size.must_equal 2
+      entities.first["Name"].to_s.must_equal "John"
+    end
+
+    it "returns an empty list when successful but the response is empty" do
+      table = Azure::Tables::Table.new("mytable")
+
+      service.stub(:call, empty_response)
+
+      entities = Azure::Tables.query_entities(table, {}, service)
+      entities.must_be_empty
+    end
+
+    it "returns an empty list if the request is unsuccessful" do
+      # TODO: We need a way to pass the error to the end user.
+
+      table = Azure::Tables::Table.new("mytable")
+
+      service.stub(:call, failed_response)
+
+      entities = Azure::Tables.query_entities(table, {}, service)
+      entities.must_be_empty
+    end
+  end
+
+  describe ".query_entity" do
+    let :successful_response do
+      StubResponse.new(success: true, body: Fixtures[:insert_entity_response_entry])
+    end
+
+    let :failed_response do
+      double(success?: false, error: Object.new)
+    end
+
+    it "returns the matching entity when it's successful" do
+      table = Azure::Tables::Table.new("mytable")
+
+      service.stub(:call, successful_response)
+
+      entity = Azure::Tables.query_entity(table, "PK", "RK", {}, service)
+      entity["PartitionKey"].to_s.must_equal "mypartitionkey"
+    end
+
+    it "returns nil if the request is unsuccessful" do
+      # TODO: We need a way to pass the error to the end user.
+
+      table = Azure::Tables::Table.new("mytable")
+
+      service.stub(:call, failed_response)
+
+      entities = Azure::Tables.query_entity(table, "PK", "RK", {}, service)
+      entities.must_be_nil
+    end
+  end
+end