azure 0.1.1 → 0.5.0

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

@@ -1,45 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,302 +0,0 @@
-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