azure 0.0.0 → 0.1.0

data/test/integration/tables/update_entity_test.rb

@@ -0,0 +1,54 @@
+require "integration/test_helper"
+
+describe "Updating Entities" do
+  after do
+    TableNameHelper.clean
+  end
+
+  before do
+    @table = Azure::Tables::Table.create(TableNameHelper.name)
+    @entity = Azure::Tables::Entity.new(
+      "PartitionKey" => "part1",
+      "RowKey"       => "row1",
+      "Address"      => "Mountain View",
+      "FirstName"    => "John",
+      "Email"        => "john@example.com"
+    )
+    @table.insert(@entity)
+  end
+
+  it "should be able to update the entity from the entity itself" do
+    result = @entity.update(
+      "PartitionKey" => "part1",
+      "RowKey"       => "row1",
+      "Address"      => "New York"
+    )
+
+    result.must_equal true
+
+    @entity["Address"].must_equal "New York"
+    @entity["FirstName"].must_equal nil
+
+    # TODO: Load the Entity to check if the properties were updated.
+  end
+
+  it "fails when it tries to update a stale entity" do
+    stale_entity = @entity.dup
+
+    @entity.update(
+      "PartitionKey" => "part1",
+      "RowKey"       => "row1",
+      "Address"      => "New York"
+    )
+
+    result = stale_entity.update(
+      "PartitionKey" => "part1",
+      "RowKey"       => "row1",
+      "Address"      => "Chicago"
+    )
+    result.must_equal false
+
+    refute stale_entity.valid?
+    stale_entity.error.code.must_equal 412
+  end
+end

data/test/integration/test_helper.rb

@@ -0,0 +1,14 @@
+require "test_helper"
+require "azure"
+
+Azure.configure do |config|
+  config.access_key     = ENV.fetch("AZURE_ACCESS_KEY")
+  config.account_name   = ENV.fetch("AZURE_ACCOUNT_NAME")
+  config.table_host     = ENV.fetch("AZURE_TABLE_HOST")
+  config.blob_host      = ENV.fetch("AZURE_BLOB_HOST")
+  config.queue_host     = ENV.fetch("AZURE_QUEUE_HOST")
+
+  config.acs_namespace  = ENV.fetch("AZURE_ACS_NAMESPACE")
+  config.sb_access_key  = ENV.fetch("AZURE_SB_ACCESS_KEY")
+  config.sb_issuer      = ENV.fetch("AZURE_SB_ISSUER")
+end

data/test/support/blobs.rb

@@ -0,0 +1,12 @@
+def create_block_blob(options={})
+  metadata  = options.fetch(:metadata, {})
+  filename  = options.fetch(:filename, Fixtures["32px-fulls-black.jpg"].to_path)
+  name      = options.fetch(:name, "myblob")
+  container = options.fetch(:container, @container)
+
+  Azure::Blobs.create_block_blob(container, name, filename, metadata)
+end
+
+def create_page_blob(container)
+  Azure::Blobs.create_page_blob(container, "myblob", {:size => 8192})
+end

data/test/support/env.rb

@@ -0,0 +1,5 @@
+def skip_if_emulator
+ if Azure.config.table_host =~ /localhost/
+   skip "This test will only run in Live environment"
+ end
+end

data/test/support/fixtures.rb

@@ -0,0 +1,22 @@
+require "pathname"
+
+Fixtures = Hash.new do |hash, fixture|
+  if path = Fixtures.xml?(fixture)
+    hash[fixture] = path.read
+  elsif path = Fixtures.file?(fixture)
+    hash[fixture] = path
+  end
+end
+
+def Fixtures.root
+  Pathname("../../fixtures").expand_path(__FILE__)
+end
+
+def Fixtures.file?(fixture)
+  path = root.join(fixture)
+  path.file? && path
+end
+
+def Fixtures.xml?(fixture)
+  file?("#{fixture}.xml")
+end

data/test/support/stubs.rb

@@ -0,0 +1,28 @@
+require "ostruct"
+
+module Stubs
+  def double(messages={})
+    OpenStruct.new(messages)
+  end
+end
+
+class MiniTest::Mock
+  def stub(name, value=nil)
+    metaclass = class << self; self; end
+    metaclass.send :define_method, name do |*args|
+      value
+    end
+  end
+
+  alias_method :expect_without_stub_support, :expect
+
+  def expect(name, *args)
+    metaclass = class << self; self; end
+    metaclass.send :undef_method, name if respond_to?(name)
+    expect_without_stub_support(name, *args)
+  end
+end
+
+class MiniTest::Unit::TestCase
+  include Stubs
+end

data/test/support/table_names.rb

@@ -0,0 +1,44 @@
+class NameGenerator
+  def initialize(&cleanup_proc)
+    @cleanup_proc = cleanup_proc
+    @names = []
+  end
+
+  def name
+    alpha = ("a".."z").to_a
+    name = 10.times.map { alpha[Random.rand(alpha.size)]}.join
+    @names << name
+    name
+  end
+
+  def clean
+    @names.reject! do |name|
+      @cleanup_proc.call(name)
+    end
+  end
+end
+
+TableNameHelper = NameGenerator.new do |name|
+  table = Azure::Tables::Table.new(name)
+  Azure::Tables.delete(table)
+end
+
+ContainerNameHelper = NameGenerator.new do |name|
+  container = Azure::Blobs::Container.new(name)
+  container.delete
+end
+
+QueueNameHelper = NameGenerator.new do |name|
+  queue = Azure::Queues::Queue.new(name)
+  queue.delete
+end
+
+ServiceBusQueueNameHelper = NameGenerator.new do |name|
+  queue = Azure::ServiceBus::Queues::Queue.new(name)
+  queue.delete
+end
+
+ServiceBusTopicNameHelper = NameGenerator.new do |name|
+  topic = Azure::ServiceBus::Topics::Topic.new(name)
+  topic.delete
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require "minitest/autorun"
+
+begin
+  require "purdytest"
+rescue LoadError
+  # Oh well, no colorized tests for you. You can always use minitest/pride if
+  # you want :P
+end
+
+Dir["./test/support/**/*.rb"].each { |dep| require dep }

data/test/unit/atom_test.rb

@@ -0,0 +1,58 @@
+require "test_helper"
+require "azure/atom"
+
+describe "Generating Atom entries with property lists" do
+  it "lists the properties in the node" do
+    entry = Atom::Entry.new do |entry|
+      entry.properties do |props|
+        props["Prop1Name"] = "Prop1Value"
+        props["Prop2Name"] = "Prop2Value"
+      end
+    end
+
+    entry.properties.first.name.must_equal "d:Prop1Name"
+    entry.properties.first.content.must_equal "Prop1Value"
+
+    entry.properties.last.name.must_equal "d:Prop2Name"
+    entry.properties.last.content.must_equal "Prop2Value"
+  end
+
+  it "can bulk-update a property list" do
+    entry = Atom::Entry.new do |entry|
+      entry.properties.merge(a: 1, b: 2, c: 3)
+    end
+
+    doc = XML::Parser.string(entry.to_xml).parse
+    doc.find("//d:a[text() = '1']").wont_be_empty
+    doc.find("//d:b[text() = '2']").wont_be_empty
+    doc.find("//d:c[text() = '3']").wont_be_empty
+  end
+
+  it "can set properties in several ways" do
+    entry = Atom::Entry.new do |entry|
+      entry.properties["a"] = 1
+      entry.properties.merge(b: 2, c: 3)
+      entry.properties do |props|
+        props["d"] = 4
+      end
+    end
+
+    doc = XML::Parser.string(entry.to_xml).parse
+    doc.find("//d:a[text() = '1']").wont_be_empty
+    doc.find("//d:b[text() = '2']").wont_be_empty
+    doc.find("//d:c[text() = '3']").wont_be_empty
+    doc.find("//d:d[text() = '4']").wont_be_empty
+  end
+
+  it "generates properties with the given data type" do
+    node = Azure::Atom::Property.new("name", "value")
+    node["m:type"].must_equal "Edm.String"
+  end
+
+  it "generates properties with the given data name" do
+    node = Azure::Atom::Property.new("firstName", "value")
+    node.name.must_equal "d:firstName"
+    node = Azure::Atom::Property.new(:firstName, "value")
+    node.name.must_equal "d:firstName"
+  end
+end

data/test/unit/auth_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+require "azure/auth"
+
+describe Azure::Auth do
+  before do
+    uri = double(path: "/path")
+
+    @signer = MiniTest::Mock.new
+    @signer.stub(:name, "SharedKey")
+    @signer.stub(:sign, "Base64String==")
+
+    @request = MiniTest::Mock.new
+    @request.stub(:method, :get)
+    @request.stub(:uri, uri)
+    @request.stub(:headers, {})
+  end
+
+  it "generates a proper Authorization header" do
+    auth = Azure::Auth.new("account-name")
+    auth.sign(@request, @signer)
+
+    @request.headers["Authorization"].must_equal "SharedKey account-name:Base64String=="
+  end
+end

data/test/unit/blobs/blob_test.rb

@@ -0,0 +1,5 @@
+require "test_helper"
+require "azure/blobs/blob"
+
+describe Azure::Blobs::Blob do
+end

data/test/unit/blobs/container_test.rb

@@ -0,0 +1,67 @@
+require "test_helper"
+require "azure/blobs/container"
+
+describe Azure::Blobs::Container do
+  describe ".from_node" do
+    let :node do
+      Nokogiri::XML(Fixtures[:all_containers]) % "Container"
+    end
+
+    subject do
+      Azure::Blobs::Container.from_node(node)
+    end
+
+    it "gets the name out of the node" do
+      subject.name.must_equal "container-name"
+    end
+
+    it "gets the url out of the node" do
+      subject.url.must_equal URI("http://myaccount.blob.core.windows.net/container-name")
+    end
+
+    it "gets the properties out of the node" do
+      subject.properties["Last-Modified"].must_equal "date/time-value"
+      subject.properties["Etag"].must_equal "etag"
+    end
+
+    it "gets the metadata out of the node" do
+      subject.metadata["metadata-name"].must_equal "value"
+    end
+  end
+
+  let :service do
+    MiniTest::Mock.new
+  end
+
+  let :container do
+    Azure::Blobs::Container.new(
+      "name",
+      Azure::Blobs::URI.container("name"),
+      service
+    )
+  end
+
+  describe "#delete" do
+    it "delegates to the service's #delete_container implementation" do
+      service.expect(:delete_container, true, [container])
+      container.delete
+      service.verify
+    end
+  end
+
+  describe "#load_metadata!" do
+    it "delegates to the service's #load_container_metadata implementation" do
+      service.expect(:load_container_metadata, {}, [container])
+      container.load_metadata!
+      service.verify
+    end
+  end
+
+  describe "#save_metadata!" do
+    it "delegates to the service's #save_container_metadata implementation" do
+      service.expect(:save_container_metadata, {}, [container])
+      container.save_metadata!
+      service.verify
+    end
+  end
+end

data/test/unit/blobs/service_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+require 'azure/blobs/service'
+
+describe "Blob Services" do
+  describe "CreateBlockBlob" do
+    it "should raise an error if the file is bigger than 64 Mb" do
+      file_class = MiniTest::Mock.new
+      file_class.stub(:size, 100000000)
+
+      service = Azure::Blobs::Services::CreateBlockBlob.new("fake-access-key")
+
+      proc {
+        service.call("container_name", "blob_name", "filename", {}, file_class)
+      }.must_raise ArgumentError, "File exceeded 64Mb limit."
+    end
+  end
+end

data/test/unit/blobs/shared_access_signature_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+require "azure/blobs/shared_access_signature"
+
+describe Azure::Blobs::SharedAccessSignature do
+  let :signer do
+    signer = MiniTest::Mock.new
+    signer.stub(:sign, "SignedString==")
+    signer
+  end
+
+  let :from do
+    double(iso8601: "from")
+  end
+
+  let :to do
+    double(iso8601: "to")
+  end
+
+  let :resource do
+    resource = MiniTest::Mock.new
+    resource.stub(:resource_type, "c")
+    resource.stub(:url, URI("http://example.org/path"))
+    resource
+  end
+
+  def build(permissions, from, to, id=nil)
+    Azure::Blobs::SharedAccessSignature.new(
+      permissions, from, to, id, "account_name", signer
+    )
+  end
+
+  it "generates the URI based on the resource's URI" do
+    sas = build("r", from, to)
+
+    uri   = sas.url(resource)
+    query = sas.query_params(resource)
+
+    uri.host.must_equal resource.url.host
+    uri.query.must_equal ::URI.encode_www_form(query)
+  end
+
+  it "includes the specified permission string, start, and expiry date" do
+    params = build("r", from, to).query_params(resource)
+
+    params["sp"].must_equal "r"
+    params["st"].must_equal "from"
+    params["se"].must_equal "to"
+  end
+
+  it "includes the signedidentifier only if an identifier was provided" do
+    params = build("r", from, to).query_params(resource)
+    refute params.key?("si")
+
+    params = build("r", from, to, "id").query_params(resource)
+    params["si"].must_equal "id"
+  end
+
+  it "signs the provided parameters" do
+    signer.expect(:sign, "SignedString==", ["r\nfrom\nto\n/account_name/path\nid"])
+
+    params = build("r", from, to, "id").query_params(resource)
+    params["sig"].must_equal "SignedString=="
+
+    signer.verify
+  end
+end