diff --git a/Gemfile b/Gemfile index 0d052dda7e14762c37e54b265d4a07ae8532c440..1d4418384e7bac494726bbdb92c69f9cf9849464 100644 --- a/Gemfile +++ b/Gemfile @@ -24,7 +24,8 @@ # THE SOFTWARE. #-------------------------------------------------------------------------- source "https://rubygems.org" do - gem "azure-core", "~> 0.1.13", :require => false + gem "faraday", "~> 0.9", :require => false + gem "faraday_middleware", "~> 0.10", :require => false gem "nokogiri", "~> 1.6", ">= 1.6.8", :require => false gem "dotenv", "~> 2.0", :require => false diff --git a/common/lib/azure/storage/common/core/http_client.rb b/common/lib/azure/storage/common/core/http_client.rb index 4404e08c599683d3bf08bfa992c69fed29785ebe..28006cf990b0629b5d4672d63908d45d38fc4f2b 100644 --- a/common/lib/azure/storage/common/core/http_client.rb +++ b/common/lib/azure/storage/common/core/http_client.rb @@ -36,6 +36,8 @@ module Azure::Storage::Common::Core @agents ||= {} unless @agents.key?(key) @agents[key] = build_http(uri) + else + reuse_agent!(@agents[key]) end @agents[key] end @@ -47,6 +49,12 @@ module Azure::Storage::Common::Core private + # Empties all information that cannot be reused. + def reuse_agent!(agent) + agent.params.clear + agent.headers.clear + end + def build_http(uri) ssl_options = {} if uri.is_a?(URI) && uri.scheme.downcase == "https" diff --git a/test/integration/auth/account_shared_access_signature_test.rb b/test/integration/auth/account_shared_access_signature_test.rb index ebbb4420400db9a4301f00052461a9e430d584e6..3f855283c3e07dd20a9452415d1a85cf185a222b 100644 --- a/test/integration/auth/account_shared_access_signature_test.rb +++ b/test/integration/auth/account_shared_access_signature_test.rb @@ -44,28 +44,28 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do connection_string = "BlobEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.blob.core.windows.net;SharedAccessSignature=#{sas_token}" client = Azure::Storage::Blob::BlobService::create_from_connection_string connection_string blob_properties = client.get_blob_properties container_name, blob_name - blob_properties.wont_be_nil - blob_properties.name.must_equal blob_name - blob_properties.properties[:last_modified].wont_be_nil - blob_properties.properties[:etag].wont_be_nil - blob_properties.properties[:content_length].must_equal 512 - blob_properties.properties[:blob_type].must_equal "BlockBlob" + _(blob_properties).wont_be_nil + _(blob_properties.name).must_equal blob_name + _(blob_properties.properties[:last_modified]).wont_be_nil + _(blob_properties.properties[:etag]).wont_be_nil + _(blob_properties.properties[:content_length]).must_equal 512 + _(blob_properties.properties[:blob_type]).must_equal "BlockBlob" end it "access default signer would not throw exception" do - Azure::Storage::Common::Default::signer.must_be_nil + _(Azure::Storage::Common::Default::signer).must_be_nil end it "reads the blob properties with an object level SAS" do sas_token = generator.generate_account_sas_token service: "b", resource: "o", permissions: "r" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blob_properties = client.get_blob_properties container_name, blob_name - blob_properties.wont_be_nil - blob_properties.name.must_equal blob_name - blob_properties.properties[:last_modified].wont_be_nil - blob_properties.properties[:etag].wont_be_nil - blob_properties.properties[:content_length].must_equal 512 - blob_properties.properties[:blob_type].must_equal "BlockBlob" + _(blob_properties).wont_be_nil + _(blob_properties.name).must_equal blob_name + _(blob_properties.properties[:last_modified]).wont_be_nil + _(blob_properties.properties[:etag]).wont_be_nil + _(blob_properties.properties[:content_length]).must_equal 512 + _(blob_properties.properties[:blob_type]).must_equal "BlockBlob" end it "fails to read the blob properties using an object level SAS without permission" do @@ -80,7 +80,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_account_sas_token service: "b", resource: "c", permissions: "l" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blobs = client.list_blobs container_name - blobs.wont_be_nil + _(blobs).wont_be_nil assert blobs.length > 0 end @@ -96,7 +96,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_account_sas_token service: "b", resource: "s", permissions: "l" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) containers = client.list_containers - containers.wont_be_nil + _(containers).wont_be_nil assert containers.length > 0 end @@ -129,24 +129,24 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do connection_string = "FileEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.file.core.windows.net;SharedAccessSignature=#{sas_token}" client = Azure::Storage::File::FileService::create_from_connection_string connection_string file_properties = client.get_file_properties share_name, directory_name, file_name - file_properties.wont_be_nil - file_properties.name.must_equal file_name - file_properties.properties[:last_modified].wont_be_nil - file_properties.properties[:etag].wont_be_nil - file_properties.properties[:content_length].must_equal file_length - file_properties.properties[:type].must_equal "File" + _(file_properties).wont_be_nil + _(file_properties.name).must_equal file_name + _(file_properties.properties[:last_modified]).wont_be_nil + _(file_properties.properties[:etag]).wont_be_nil + _(file_properties.properties[:content_length]).must_equal file_length + _(file_properties.properties[:type]).must_equal "File" end it "reads the file properties with an object level SAS" do sas_token = generator.generate_account_sas_token service: "f", resource: "o", permissions: "r" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) file_properties = client.get_file_properties share_name, directory_name, file_name - file_properties.wont_be_nil - file_properties.name.must_equal file_name - file_properties.properties[:last_modified].wont_be_nil - file_properties.properties[:etag].wont_be_nil - file_properties.properties[:content_length].must_equal file_length - file_properties.properties[:type].must_equal "File" + _(file_properties).wont_be_nil + _(file_properties.name).must_equal file_name + _(file_properties.properties[:last_modified]).wont_be_nil + _(file_properties.properties[:etag]).wont_be_nil + _(file_properties.properties[:content_length]).must_equal file_length + _(file_properties.properties[:type]).must_equal "File" end it "fails to read the file properties using an object level SAS without permission" do @@ -161,7 +161,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_account_sas_token service: "f", resource: "c", permissions: "l" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) directories = client.list_directories_and_files share_name, nil - directories.wont_be_nil + _(directories).wont_be_nil assert directories.length > 0 end @@ -177,7 +177,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_account_sas_token service: "f", resource: "s", permissions: "l" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) shares = client.list_shares - shares.wont_be_nil + _(shares).wont_be_nil assert shares.length > 0 end diff --git a/test/integration/auth/blob_shared_access_signature_test.rb b/test/integration/auth/blob_shared_access_signature_test.rb index 28b2d7b8f6b4be4a81eb4f0ab1774255099c7c51..bae5b93fc640f6862922c1384dda7417797ce91e 100644 --- a/test/integration/auth/blob_shared_access_signature_test.rb +++ b/test/integration/auth/blob_shared_access_signature_test.rb @@ -47,57 +47,57 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do connection_string = "BlobEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.blob.core.windows.net;SharedAccessSignature=#{sas_token}" client = Azure::Storage::Blob::BlobService::create_from_connection_string connection_string blob_properties = client.get_blob_properties container_name, block_blob_name - blob_properties.wont_be_nil - blob_properties.name.must_equal block_blob_name - blob_properties.properties[:last_modified].wont_be_nil - blob_properties.properties[:etag].wont_be_nil - blob_properties.properties[:content_length].must_equal 512 - blob_properties.properties[:blob_type].must_equal "BlockBlob" + _(blob_properties).wont_be_nil + _(blob_properties.name).must_equal block_blob_name + _(blob_properties.properties[:last_modified]).wont_be_nil + _(blob_properties.properties[:etag]).wont_be_nil + _(blob_properties.properties[:content_length]).must_equal 512 + _(blob_properties.properties[:blob_type]).must_equal "BlockBlob" end it "reads a blob property with container permission" do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "r", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blob_properties = client.get_blob_properties container_name, block_blob_name - blob_properties.wont_be_nil - blob_properties.name.must_equal block_blob_name - blob_properties.properties[:last_modified].wont_be_nil - blob_properties.properties[:etag].wont_be_nil - blob_properties.properties[:content_length].must_equal 512 - blob_properties.properties[:blob_type].must_equal "BlockBlob" + _(blob_properties).wont_be_nil + _(blob_properties.name).must_equal block_blob_name + _(blob_properties.properties[:last_modified]).wont_be_nil + _(blob_properties.properties[:etag]).wont_be_nil + _(blob_properties.properties[:content_length]).must_equal 512 + _(blob_properties.properties[:blob_type]).must_equal "BlockBlob" end it "appends a blob with container permission" do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "a", protocol: "https,http" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blob = client.append_blob_block container_name, append_blob_name, content - blob.wont_be_nil - blob.name.must_equal append_blob_name - blob.properties[:last_modified].wont_be_nil - blob.properties[:etag].wont_be_nil - blob.properties[:append_offset].must_equal 0 - blob.properties[:committed_count].must_equal 1 + _(blob).wont_be_nil + _(blob.name).must_equal append_blob_name + _(blob.properties[:last_modified]).wont_be_nil + _(blob.properties[:etag]).wont_be_nil + _(blob.properties[:append_offset]).must_equal 0 + _(blob.properties[:committed_count]).must_equal 1 end it "snapshots a blob with container permission" do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "c", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) snapshot_id = client.create_blob_snapshot container_name, block_blob_name - snapshot_id.wont_be_nil + _(snapshot_id).wont_be_nil end it "leases a blob with container permission" do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "w", protocol: "https,http" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) lease_id = client.acquire_blob_lease container_name, block_blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil end it "list a blob with container permission" do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "l", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blobs = client.list_blobs container_name - blobs.wont_be_nil + _(blobs).wont_be_nil assert blobs.length > 0 end @@ -105,52 +105,52 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "d", protocol: "https,http" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.delete_blob container_name, page_blob_name - result.must_be_nil + _(result).must_be_nil end it "reads a blob property with blob permission" do sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "r", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blob_properties = client.get_blob_properties container_name, block_blob_name - blob_properties.wont_be_nil - blob_properties.name.must_equal block_blob_name - blob_properties.properties[:last_modified].wont_be_nil - blob_properties.properties[:etag].wont_be_nil - blob_properties.properties[:content_length].must_equal 512 - blob_properties.properties[:blob_type].must_equal "BlockBlob" + _(blob_properties).wont_be_nil + _(blob_properties.name).must_equal block_blob_name + _(blob_properties.properties[:last_modified]).wont_be_nil + _(blob_properties.properties[:etag]).wont_be_nil + _(blob_properties.properties[:content_length]).must_equal 512 + _(blob_properties.properties[:blob_type]).must_equal "BlockBlob" end it "appends a blob with blob permission" do sas_token = generator.generate_service_sas_token "#{container_name}/#{append_blob_name}", service: "b", resource: "b", permissions: "a", protocol: "https,http" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) blob = client.append_blob_block container_name, append_blob_name, content - blob.wont_be_nil - blob.name.must_equal append_blob_name - blob.properties[:last_modified].wont_be_nil - blob.properties[:etag].wont_be_nil - blob.properties[:append_offset].must_equal 0 - blob.properties[:committed_count].must_equal 1 + _(blob).wont_be_nil + _(blob.name).must_equal append_blob_name + _(blob.properties[:last_modified]).wont_be_nil + _(blob.properties[:etag]).wont_be_nil + _(blob.properties[:append_offset]).must_equal 0 + _(blob.properties[:committed_count]).must_equal 1 end it "snapshots a blob with blob permission" do sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "c", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) snapshot_id = client.create_blob_snapshot container_name, block_blob_name - snapshot_id.wont_be_nil + _(snapshot_id).wont_be_nil end it "leases a blob with blob permission" do sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "w", protocol: "https,http" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) lease_id = client.acquire_blob_lease container_name, block_blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil end it "deletes a blob with blob permission" do sas_token = generator.generate_service_sas_token "#{container_name}/#{page_blob_name}", service: "b", resource: "b", permissions: "d", protocol: "https" client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.delete_blob container_name, page_blob_name - result.must_be_nil + _(result).must_be_nil end end end diff --git a/test/integration/auth/file_shared_access_signature_test.rb b/test/integration/auth/file_shared_access_signature_test.rb index f024b41cd0c409a2c4cbf12ec03c371e11efa9f7..bcb5badf5fe14cd564f0b7bc62d9a176c7d8c933 100644 --- a/test/integration/auth/file_shared_access_signature_test.rb +++ b/test/integration/auth/file_shared_access_signature_test.rb @@ -49,11 +49,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do new_file_name = FileNameHelper.name new_file = subject.create_file share_name, directory_name, new_file_name, file_length - new_file.wont_be_nil - new_file.name.must_equal new_file_name - new_file.properties[:last_modified].wont_be_nil - new_file.properties[:etag].wont_be_nil - new_file.properties[:content_length].wont_be_nil + _(new_file).wont_be_nil + _(new_file.name).must_equal new_file_name + _(new_file.properties[:last_modified]).wont_be_nil + _(new_file.properties[:etag]).wont_be_nil + _(new_file.properties[:content_length]).wont_be_nil end it "create a file with share permission" do @@ -62,11 +62,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do new_file_name = FileNameHelper.name new_file = subject.create_file share_name, directory_name, new_file_name, file_length - new_file.wont_be_nil - new_file.name.must_equal new_file_name - new_file.properties[:last_modified].wont_be_nil - new_file.properties[:etag].wont_be_nil - new_file.properties[:content_length].wont_be_nil + _(new_file).wont_be_nil + _(new_file.name).must_equal new_file_name + _(new_file.properties[:last_modified]).wont_be_nil + _(new_file.properties[:etag]).wont_be_nil + _(new_file.properties[:content_length]).wont_be_nil end it "write a file with share permission" do @@ -75,14 +75,14 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do new_file_name = FileNameHelper.name new_file = subject.create_file share_name, directory_name, new_file_name, file_length - new_file.wont_be_nil + _(new_file).wont_be_nil sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "w", protocol: "https" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) file = subject.put_file_range share_name, directory_name, new_file_name, 0, file_length - 1, content - file.wont_be_nil - file.name.must_equal new_file_name + _(file).wont_be_nil + _(file.name).must_equal new_file_name end it "reads a file property with share permission" do @@ -90,19 +90,19 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) file_properties = client.get_file_properties share_name, directory_name, file_name - file_properties.wont_be_nil - file_properties.name.must_equal file_name - file_properties.properties[:last_modified].wont_be_nil - file_properties.properties[:etag].wont_be_nil - file_properties.properties[:content_length].must_equal file_length - file_properties.properties[:type].must_equal "File" + _(file_properties).wont_be_nil + _(file_properties.name).must_equal file_name + _(file_properties.properties[:last_modified]).wont_be_nil + _(file_properties.properties[:etag]).wont_be_nil + _(file_properties.properties[:content_length]).must_equal file_length + _(file_properties.properties[:type]).must_equal "File" end it "list a file with share permission" do sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "l", protocol: "https" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) files = client.list_directories_and_files share_name, nil - files.wont_be_nil + _(files).wont_be_nil assert files.length > 0 end @@ -110,7 +110,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "d", protocol: "https,http" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.delete_file share_name, directory_name, file_name - result.must_be_nil + _(result).must_be_nil end it "create a file with file permission" do @@ -119,11 +119,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do new_file_name = FileNameHelper.name new_file = subject.create_file share_name, directory_name, new_file_name, file_length - new_file.wont_be_nil - new_file.name.must_equal new_file_name - new_file.properties[:last_modified].wont_be_nil - new_file.properties[:etag].wont_be_nil - new_file.properties[:content_length].wont_be_nil + _(new_file).wont_be_nil + _(new_file.name).must_equal new_file_name + _(new_file.properties[:last_modified]).wont_be_nil + _(new_file.properties[:etag]).wont_be_nil + _(new_file.properties[:content_length]).wont_be_nil end it "write a file with file permission" do @@ -132,33 +132,33 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do new_file_name = FileNameHelper.name new_file = subject.create_file share_name, directory_name, new_file_name, file_length - new_file.wont_be_nil + _(new_file).wont_be_nil sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "w", protocol: "https" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) file = subject.put_file_range share_name, directory_name, new_file_name, 0, file_length - 1, content - file.wont_be_nil - file.name.must_equal new_file_name + _(file).wont_be_nil + _(file.name).must_equal new_file_name end it "reads a file property with file permission" do sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "r", protocol: "https" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) file_properties = client.get_file_properties share_name, directory_name, file_name - file_properties.wont_be_nil - file_properties.name.must_equal file_name - file_properties.properties[:last_modified].wont_be_nil - file_properties.properties[:etag].wont_be_nil - file_properties.properties[:content_length].must_equal file_length - file_properties.properties[:type].must_equal "File" + _(file_properties).wont_be_nil + _(file_properties.name).must_equal file_name + _(file_properties.properties[:last_modified]).wont_be_nil + _(file_properties.properties[:etag]).wont_be_nil + _(file_properties.properties[:content_length]).must_equal file_length + _(file_properties.properties[:type]).must_equal "File" end it "deletes a file with file permission" do sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "d", protocol: "https" client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.delete_file share_name, directory_name, file_name - result.must_be_nil + _(result).must_be_nil end end end diff --git a/test/integration/auth/queue_shared_access_signature_test.rb b/test/integration/auth/queue_shared_access_signature_test.rb index 90834f30215296b093c6e4c20c65d5974dac3c9f..f693f3c88dc4757b50454c487bada635e0ad6aad 100644 --- a/test/integration/auth/queue_shared_access_signature_test.rb +++ b/test/integration/auth/queue_shared_access_signature_test.rb @@ -44,7 +44,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do connection_string = "QueueEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.queue.core.windows.net;SharedAccessSignature=#{sas_token}" client = Azure::Storage::Queue::QueueService::create_from_connection_string connection_string message = client.peek_messages queue_name, number_of_messages: 2 - message.wont_be_nil + _(message).wont_be_nil assert message.length > 1 end @@ -52,7 +52,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_service_sas_token queue_name, service: "q", permissions: "r", protocol: "https,http" client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) message = client.peek_messages queue_name, number_of_messages: 2 - message.wont_be_nil + _(message).wont_be_nil assert message.length > 1 end @@ -60,12 +60,12 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do sas_token = generator.generate_service_sas_token queue_name, service: "q", permissions: "a", protocol: "https" client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.create_message queue_name, message_3 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_be_nil - result[0].pop_receipt.wont_be_nil - result[0].id.wont_be_nil + _(result.length).must_equal 1 + _(result[0].message_text).must_be_nil + _(result[0].pop_receipt).wont_be_nil + _(result[0].id).wont_be_nil end it "processes and updates a message to the queue with a SAS" do @@ -73,8 +73,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) message = client.list_messages queue_name, 10 new_pop_receipt, time_next_visible = client.update_message queue_name, message[0].id, message[0].pop_receipt, "updated message", 10 - new_pop_receipt.wont_be_nil - time_next_visible.wont_be_nil + _(new_pop_receipt).wont_be_nil + _(time_next_visible).wont_be_nil end it "deletes a message in the queue with a SAS" do diff --git a/test/integration/auth/table_shared_access_signature_test.rb b/test/integration/auth/table_shared_access_signature_test.rb index 9a842108408c5e908ec66298c7e7b7300b0babb4..7387fa121d031d7b250b9e642d024d886ee7c76c 100644 --- a/test/integration/auth/table_shared_access_signature_test.rb +++ b/test/integration/auth/table_shared_access_signature_test.rb @@ -46,9 +46,9 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService::create_from_connection_string connection_string query = { filter: "RowKey eq '1-1'" } result = client.query_entities table_name, query - result.wont_be_nil - result[0].properties["PartitionKey"].must_equal entity1[:PartitionKey] - result[0].properties["Content"].must_equal entity1[:Content] + _(result).wont_be_nil + _(result[0].properties["PartitionKey"]).must_equal entity1[:PartitionKey] + _(result[0].properties["Content"]).must_equal entity1[:Content] end it "queries a table entity with a SAS" do @@ -56,18 +56,18 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) query = { filter: "RowKey eq '1-1'" } result = client.query_entities table_name, query - result.wont_be_nil - result[0].properties["PartitionKey"].must_equal entity1[:PartitionKey] - result[0].properties["Content"].must_equal entity1[:Content] + _(result).wont_be_nil + _(result[0].properties["PartitionKey"]).must_equal entity1[:PartitionKey] + _(result[0].properties["Content"]).must_equal entity1[:Content] end it "inserts a table entity with a SAS" do sas_token = generator.generate_service_sas_token table_name, service: "t", permissions: "a", protocol: "https" client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) result = client.insert_entity table_name, entity4 - result.wont_be_nil - result.properties["PartitionKey"].must_equal entity4[:PartitionKey] - result.properties["Content"].must_equal entity4[:Content] + _(result).wont_be_nil + _(result.properties["PartitionKey"]).must_equal entity4[:PartitionKey] + _(result.properties["Content"]).must_equal entity4[:Content] end it "updates a table entity with a SAS" do @@ -75,7 +75,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) entity2[:Content] = "test entity content-2-updated" result = client.update_entity table_name, entity2 - result.wont_be_nil + _(result).wont_be_nil end it "queries a table entity with pk in the SAS" do @@ -84,8 +84,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) query = { top: 10 } result = client.query_entities table_name, query - result.wont_be_nil - result.length.must_equal 2 + _(result).wont_be_nil + _(result.length).must_equal 2 end it "queries a table entity with rk in the SAS" do @@ -95,8 +95,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) query = { top: 10 } result = client.query_entities table_name, query - result.wont_be_nil - result.length.must_equal 1 + _(result).wont_be_nil + _(result.length).must_equal 1 end it "deletes a table entity with a SAS" do @@ -104,6 +104,6 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token }) entity2[:Content] = "test entity content-2-updated" result = client.delete_entity table_name, entity3[:PartitionKey], entity3[:RowKey] - result.must_be_nil + _(result).must_be_nil end end diff --git a/test/integration/blob/append_blob_test.rb b/test/integration/blob/append_blob_test.rb index 2899bc1ef8c7a8ba4eadd28a4993ec356f712c5b..1b5c48ec66fed4a24fa910816b8308f6bff42983 100644 --- a/test/integration/blob/append_blob_test.rb +++ b/test/integration/blob/append_blob_test.rb @@ -43,7 +43,7 @@ describe Azure::Storage::Blob::BlobService do exception = assert_raises(Azure::Storage::Common::Core::StorageError) do subject.create_append_blob_from_content container_name, blob_name, content, max_size: maxSize end - exception.message.must_include("Given content has exceeded the specified maximum size for the blob.") + _(exception.message).must_include("Given content has exceeded the specified maximum size for the blob.") end it "4MB + 1 byte IO with no 'size' and 4MB max size fails with max size condition not met" do @@ -65,8 +65,8 @@ describe Azure::Storage::Blob::BlobService do exception = assert_raises(Azure::Core::Http::HTTPError) do subject.create_append_blob_from_content container_name, blob_name, content, max_size: maxSize end - exception.status_code.must_equal 412 - exception.message.must_include("MaxBlobSizeConditionNotMet") + _(exception.status_code).must_equal 412 + _(exception.message).must_include("MaxBlobSizeConditionNotMet") end it "4MB string payload with 4MB max size and duplicate request fails" do @@ -79,8 +79,8 @@ describe Azure::Storage::Blob::BlobService do exception = assert_raises(Azure::Core::Http::HTTPError) do tempSubject.create_append_blob_from_content container_name, blob_name, content, max_size: length end - exception.status_code.must_equal 412 - exception.message.must_include("AppendPositionConditionNotMet") + _(exception.status_code).must_equal 412 + _(exception.message).must_include("AppendPositionConditionNotMet") end it "1MB string payload works" do @@ -90,10 +90,10 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_append_blob_from_content container_name, blob_name, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - blob.properties[:content_type].must_equal "text/plain; charset=UTF-8" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "4MB string payload works" do @@ -102,10 +102,10 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_page_blob_from_content container_name, blob_name, length, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - blob.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(blob.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "5MB string payload works" do @@ -114,9 +114,9 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_append_blob_from_content container_name, blob_name, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "IO payload works" do @@ -129,9 +129,9 @@ describe Azure::Storage::Blob::BlobService do file.seek 0 subject.create_append_blob_from_content container_name, blob_name, file blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) ensure unless file.nil? file.close @@ -150,14 +150,14 @@ describe Azure::Storage::Blob::BlobService do it "creates an append blob" do blob = subject.create_append_blob container_name, blob_name - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true end it "creates an append blob with complex name" do blob = subject.create_append_blob container_name, complex_blob_name - blob.name.must_equal complex_blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal complex_blob_name + _(is_boolean(blob.encrypted)).must_equal true complex_blob_name.force_encoding("UTF-8") found_complex_name = false @@ -166,7 +166,7 @@ describe Azure::Storage::Blob::BlobService do found_complex_name = true if blob.name == complex_blob_name } - found_complex_name.must_equal true + _(found_complex_name).must_equal true end it "sets additional properties when the options hash is used" do @@ -179,19 +179,19 @@ describe Azure::Storage::Blob::BlobService do } blob = subject.create_append_blob container_name, blob_name, options - is_boolean(blob.encrypted).must_equal true + _(is_boolean(blob.encrypted)).must_equal true blob = subject.get_blob_properties container_name, blob_name - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:blob_type].must_equal "AppendBlob" - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:blob_type]).must_equal "AppendBlob" + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" blob = subject.get_blob_metadata container_name, blob_name - blob.name.must_equal blob_name - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(blob.name).must_equal blob_name + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" end it "errors if the container does not exist" do @@ -214,11 +214,11 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works blob = subject.create_append_blob container_name, append_blob_name, lease_id: lease_id - blob.name.must_equal append_blob_name + _(blob.name).must_equal append_blob_name end end @@ -235,22 +235,22 @@ describe Azure::Storage::Blob::BlobService do options = { content_md5: Base64.strict_encode64(Digest::MD5.digest(content)) } blob = subject.append_blob_block container_name, blob_name, content, options - is_boolean(blob.encrypted).must_equal true + _(is_boolean(blob.encrypted)).must_equal true # verify - blob.properties[:content_md5].must_equal Base64.strict_encode64(Digest::MD5.digest(content)) - blob.properties[:append_offset].must_equal 0 + _(blob.properties[:content_md5]).must_equal Base64.strict_encode64(Digest::MD5.digest(content)) + _(blob.properties[:append_offset]).must_equal 0 blob = subject.get_blob_properties container_name, blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:blob_type].must_equal "AppendBlob" - blob.properties[:content_length].must_equal 512 - blob.properties[:committed_count].must_equal 1 + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:blob_type]).must_equal "AppendBlob" + _(blob.properties[:content_length]).must_equal 512 + _(blob.properties[:committed_count]).must_equal 1 # append another and verify blob = subject.append_blob_block container_name, blob_name, content - blob.properties[:append_offset].must_equal 512 - blob.properties[:committed_count].must_equal 2 + _(blob.properties[:append_offset]).must_equal 512 + _(blob.properties[:committed_count]).must_equal 2 end it "appends a block as part of an append blob with wrong MD5" do @@ -270,9 +270,9 @@ describe Azure::Storage::Blob::BlobService do options = { max_size: 600.to_s } blob = subject.append_blob_block container_name, blob_name, content, options - is_boolean(blob.encrypted).must_equal true - blob.properties[:append_offset].must_equal 0 - blob.properties[:committed_count].must_equal 1 + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:append_offset]).must_equal 0 + _(blob.properties[:committed_count]).must_equal 1 exception = assert_raises(Azure::Core::Http::HTTPError) do subject.append_blob_block container_name, blob_name, content, options @@ -285,15 +285,15 @@ describe Azure::Storage::Blob::BlobService do subject.create_append_blob container_name, blob_name blob = subject.append_blob_block container_name, blob_name, content - is_boolean(blob.encrypted).must_equal true - blob.properties[:append_offset].must_equal 0 - blob.properties[:committed_count].must_equal 1 + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:append_offset]).must_equal 0 + _(blob.properties[:committed_count]).must_equal 1 options = { append_position: 512.to_s } blob = subject.append_blob_block container_name, blob_name, content, options - is_boolean(blob.encrypted).must_equal true - blob.properties[:append_offset].must_equal 512 - blob.properties[:committed_count].must_equal 2 + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:append_offset]).must_equal 512 + _(blob.properties[:committed_count]).must_equal 2 exception = assert_raises(Azure::Core::Http::HTTPError) do subject.append_blob_block container_name, blob_name, content, options @@ -315,19 +315,19 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works blob = subject.append_blob_block container_name, append_blob_name, content, lease_id: lease_id - blob.properties[:content_md5].must_equal Base64.strict_encode64(Digest::MD5.digest(content)) - blob.properties[:append_offset].must_equal 0 + _(blob.properties[:content_md5]).must_equal Base64.strict_encode64(Digest::MD5.digest(content)) + _(blob.properties[:append_offset]).must_equal 0 blob = subject.get_blob_properties container_name, append_blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:blob_type].must_equal "AppendBlob" - blob.properties[:content_length].must_equal 512 - blob.properties[:committed_count].must_equal 1 + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:blob_type]).must_equal "AppendBlob" + _(blob.properties[:content_length]).must_equal 512 + _(blob.properties[:committed_count]).must_equal 1 end end end diff --git a/test/integration/blob/blob_anonymous_access_test.rb b/test/integration/blob/blob_anonymous_access_test.rb index f439a6de0706c8afddc73a171251d7512108e6b6..78c13346a1bd29175e47add33bb0f6046b010af0 100644 --- a/test/integration/blob/blob_anonymous_access_test.rb +++ b/test/integration/blob/blob_anonymous_access_test.rb @@ -48,10 +48,10 @@ describe Azure::Storage::Blob::BlobService do subject.create_block_blob container_name, blob_name, content subject.set_container_acl container_name, public_access_level result = anonymous_blob_client.list_blobs container_name - result.size.must_equal 1 + _(result.size).must_equal 1 blob, body = anonymous_blob_client.get_blob container_name, blob_name - blob.name.must_equal blob_name - body.must_equal content + _(blob.name).must_equal blob_name + _(body).must_equal content end it "test anonymous access for private container does not work" do @@ -67,8 +67,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "404" - description.must_include "The specified resource does not exist." + _(status_code).must_equal "404" + _(description).must_include "The specified resource does not exist." end end end diff --git a/test/integration/blob/blob_gb18030_test.rb b/test/integration/blob/blob_gb18030_test.rb index 1f097a70b4364dab9af6c26bd33f876ee5c98775..950c28fccc405e452ad02bc7f43a7395b9f7c87f 100644 --- a/test/integration/blob/blob_gb18030_test.rb +++ b/test/integration/blob/blob_gb18030_test.rb @@ -75,7 +75,7 @@ describe "Blob GB-18030" do subject.create_block_blob container_name, test_name, "hi" blobs = subject.list_blobs container_name blobs.each { |value| - value.name.must_equal test_name + _(value.name).must_equal test_name } subject.delete_blob container_name, test_name end @@ -93,7 +93,7 @@ describe "Blob GB-18030" do subject.create_block_blob container_name, test_name, "hi" blobs = subject.list_blobs container_name blobs.each { |value| - value.name.encode("UTF-8").must_equal test_name.encode("UTF-8") + _(value.name.encode("UTF-8")).must_equal test_name.encode("UTF-8") } subject.delete_blob container_name, test_name end @@ -107,7 +107,7 @@ describe "Blob GB-18030" do subject.set_blob_metadata container_name, blob_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -119,7 +119,7 @@ describe "Blob GB-18030" do subject.set_blob_metadata container_name, blob_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -132,7 +132,7 @@ describe "Blob GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -145,7 +145,7 @@ describe "Blob GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -156,7 +156,7 @@ describe "Blob GB-18030" do content = v.encode("UTF-8") subject.create_block_blob container_name, blob_name, content blob, returned_content = subject.get_blob container_name, blob_name - returned_content.must_equal content + _(returned_content).must_equal content } end @@ -169,7 +169,7 @@ describe "Blob GB-18030" do blob, returned_content = subject.get_blob container_name, blob_name charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end @@ -186,7 +186,7 @@ describe "Blob GB-18030" do blob, returned_content = subject.get_blob container_name, blob_name charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end @@ -203,7 +203,7 @@ describe "Blob GB-18030" do blob, returned_content = subject.get_blob container_name, blob_name charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end end diff --git a/test/integration/blob/blob_metadata_test.rb b/test/integration/blob/blob_metadata_test.rb index fb1bfea3677eae5b44b27abd27f79b138504af45..1f67fb82c09e9da3256bf980fd520899b3132f65 100644 --- a/test/integration/blob/blob_metadata_test.rb +++ b/test/integration/blob/blob_metadata_test.rb @@ -40,13 +40,13 @@ describe Azure::Storage::Blob::BlobService do it "sets and gets metadata for a blob" do result = subject.set_blob_metadata container_name, blob_name, metadata - result.must_be_nil + _(result).must_be_nil blob = subject.get_blob_metadata container_name, blob_name - blob.encrypted.must_be_nil + _(blob.encrypted).must_be_nil metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } end @@ -57,12 +57,12 @@ describe Azure::Storage::Blob::BlobService do it "gets metadata for a blob snapshot (when set during create)" do blob = subject.get_blob_metadata container_name, blob_name, snapshot: snapshot - blob.encrypted.must_be_nil + _(blob.encrypted).must_be_nil - blob.snapshot.must_equal snapshot + _(blob.snapshot).must_equal snapshot metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } end @@ -100,20 +100,20 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" + _(status_code).must_equal "412" # assert right lease succeeds blob = subject.get_blob_metadata container_name, page_blob_name, lease_id: new_lease_id - blob.wont_be_nil + _(blob).wont_be_nil metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } # assert no lease succeeds blob = subject.get_blob_metadata container_name, page_blob_name - blob.wont_be_nil + _(blob).wont_be_nil metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } end @@ -133,16 +133,16 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert right lease succeeds result = subject.set_blob_metadata container_name, page_blob_name, metadata, lease_id: new_lease_id - result.must_be_nil + _(result).must_be_nil blob = subject.get_blob_metadata container_name, page_blob_name - blob.wont_be_nil + _(blob).wont_be_nil metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } # prove that no lease fails status_code = "" @@ -153,8 +153,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." end end end diff --git a/test/integration/blob/blob_pages_test.rb b/test/integration/blob/blob_pages_test.rb index 0aea63e5e4e438879c1e501df2ff67cccbabf3c5..3559f2f847d219b5a93b53e306bb8542e17bfd56 100644 --- a/test/integration/blob/blob_pages_test.rb +++ b/test/integration/blob/blob_pages_test.rb @@ -50,10 +50,10 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_page_blob_from_content container_name, blob_name, length, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - blob.properties[:content_type].must_equal "text/plain; charset=UTF-8" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "4MB string payload works" do @@ -62,10 +62,10 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_page_blob_from_content container_name, blob_name, length, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - blob.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(blob.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "5MB string payload works" do @@ -74,9 +74,9 @@ describe Azure::Storage::Blob::BlobService do blob_name = BlobNameHelper.name subject.create_page_blob_from_content container_name, blob_name, length, content blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "IO payload works" do @@ -89,9 +89,9 @@ describe Azure::Storage::Blob::BlobService do file.seek 0 subject.create_page_blob_from_content container_name, blob_name, length, file blob, body = subject.get_blob(container_name, blob_name) - blob.name.must_equal blob_name - blob.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(blob.name).must_equal blob_name + _(blob.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) ensure unless file.nil? file.close @@ -110,10 +110,10 @@ describe Azure::Storage::Blob::BlobService do subject.put_blob_pages container_name, blob_name, 1024, 1535, content ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 1536 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 end it "lease id works for put_blob_pages" do @@ -132,17 +132,17 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert right lease succeeds subject.put_blob_pages container_name, page_blob_name, 0, 511, content, lease_id: lease_id subject.put_blob_pages container_name, page_blob_name, 1024, 1535, content, lease_id: lease_id ranges = subject.list_page_blob_ranges container_name, page_blob_name, start_range: 0, end_range: 1536 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 end end @@ -152,7 +152,7 @@ describe Azure::Storage::Blob::BlobService do 512.times.each { |i| content << "@" } blob = subject.put_blob_pages container_name, blob_name2, 0, 511, content - is_boolean(blob.encrypted).must_equal true + _(is_boolean(blob.encrypted)).must_equal true assert_raises(Azure::Core::Http::HTTPError) do subject.put_blob_pages container_name, blob_name2, 1024, 1535, content, if_none_match: blob.properties[:etag] @@ -164,7 +164,7 @@ describe Azure::Storage::Blob::BlobService do 512.times.each { |i| content << "@" } blob = subject.put_blob_pages container_name, blob_name, 0, 511, content - is_boolean(blob.encrypted).must_equal true + _(is_boolean(blob.encrypted)).must_equal true subject.put_blob_pages container_name, blob_name, 1024, 1535, content, if_match: blob.properties[:etag] end end @@ -179,13 +179,13 @@ describe Azure::Storage::Blob::BlobService do subject.put_blob_pages container_name, blob_name, 2048, 2559, content ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 2560 - ranges.length.must_equal 3 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 - ranges[2][0].must_equal 2048 - ranges[2][1].must_equal 2559 + _(ranges.length).must_equal 3 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 + _(ranges[2][0]).must_equal 2048 + _(ranges[2][1]).must_equal 2559 } describe "when both start_range and end_range are specified" do @@ -193,11 +193,11 @@ describe Azure::Storage::Blob::BlobService do subject.clear_blob_pages container_name, blob_name, 512, 1535 ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 2560 - ranges.length.must_equal 2 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 2048 - ranges[1][1].must_equal 2559 + _(ranges.length).must_equal 2 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 2048 + _(ranges[1][1]).must_equal 2559 end end end @@ -213,10 +213,10 @@ describe Azure::Storage::Blob::BlobService do it "lists the active blob pages" do ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 1536 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 end it "list blob pages in the snapshot" do @@ -231,17 +231,17 @@ describe Azure::Storage::Blob::BlobService do # verify that even the blob has been altered, the returned list # will not contain the change if snapshot is specified ranges = subject.list_page_blob_ranges container_name, blob_name3, snapshot: snapshot1 - ranges.length.must_equal 2 + _(ranges.length).must_equal 2 # verify the change ranges = subject.list_page_blob_ranges container_name, blob_name3 - ranges.length.must_equal 3 + _(ranges.length).must_equal 3 # take another snapshot snapshot2 = subject.create_blob_snapshot container_name, blob_name3 # only change between snapshot1 and snapshot2 will be listed ranges = subject.list_page_blob_ranges container_name, blob_name3, snapshot: snapshot2, previous_snapshot: snapshot1 - ranges.length.must_equal 1 - ranges[0][0].must_equal 2048 - ranges[0][1].must_equal 2559 + _(ranges.length).must_equal 1 + _(ranges[0][0]).must_equal 2048 + _(ranges[0][1]).must_equal 2559 end it "lease id works for list_page_blob_ranges" do @@ -265,14 +265,14 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert correct lease works ranges = subject.list_page_blob_ranges container_name, page_blob_name, lease_id: new_lease_id - ranges.length.must_equal 3 + _(ranges.length).must_equal 3 # assert no lease works ranges = subject.list_page_blob_ranges container_name, page_blob_name - ranges.length.must_equal 3 + _(ranges.length).must_equal 3 end end end diff --git a/test/integration/blob/blob_properties_test.rb b/test/integration/blob/blob_properties_test.rb index c1fb28f651d0753131b331f7bc2c4c3bae3d11a5..13eae1d337567f8597113c1c63a50684dc5d6fbb 100644 --- a/test/integration/blob/blob_properties_test.rb +++ b/test/integration/blob/blob_properties_test.rb @@ -45,11 +45,11 @@ describe Azure::Storage::Blob::BlobService do it "sets and gets properties for a blob" do result = subject.set_blob_properties container_name, blob_name, options - result.must_be_nil + _(result).must_be_nil blob = subject.get_blob_properties container_name, blob_name - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] end describe "when a blob has a snapshot" do @@ -61,10 +61,10 @@ describe Azure::Storage::Blob::BlobService do snapshot = subject.create_blob_snapshot container_name, blob_name blob = subject.get_blob_properties container_name, blob_name, snapshot: snapshot - blob.snapshot.must_equal snapshot - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] + _(blob.snapshot).must_equal snapshot + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] end it "errors if the snapshot does not exist" do @@ -100,19 +100,19 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" + _(status_code).must_equal "412" # assert right lease succeeds blob = subject.get_blob_properties container_name, page_blob_name, lease_id: new_lease_id - blob.wont_be_nil - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] + _(blob).wont_be_nil + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] # assert no lease succeeds blob = subject.get_blob_properties container_name, page_blob_name - blob.wont_be_nil - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] + _(blob).wont_be_nil + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] end it "lease id works for set_blob_properties" do @@ -131,16 +131,16 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert right lease succeeds result = subject.set_blob_properties container_name, page_blob_name, options.merge(lease_id: new_lease_id) - result.must_be_nil + _(result).must_be_nil blob = subject.get_blob_properties container_name, page_blob_name - blob.wont_be_nil - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] + _(blob).wont_be_nil + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] # prove that no lease fails status_code = "" description = "" @@ -150,8 +150,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." end end end diff --git a/test/integration/blob/blob_service_properties_test.rb b/test/integration/blob/blob_service_properties_test.rb index 26e1833bb6df43d5c0d65c20215042410ada0b0d..20ead92cfc4da3048d76aca3ba1d0ded68eb0190 100644 --- a/test/integration/blob/blob_service_properties_test.rb +++ b/test/integration/blob/blob_service_properties_test.rb @@ -42,13 +42,13 @@ describe Azure::Storage::Blob::BlobService do properties.hour_metrics.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end it "sets the service properties use default values" do properties = Azure::Storage::Common::Service::StorageServiceProperties.new result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end describe "#set_service_properties with logging" do @@ -61,7 +61,7 @@ describe Azure::Storage::Blob::BlobService do properties.logging.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end it "without retention" do @@ -73,7 +73,7 @@ describe Azure::Storage::Blob::BlobService do properties.logging.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end end @@ -86,7 +86,7 @@ describe Azure::Storage::Blob::BlobService do properties.hour_metrics.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end it "with minuite metrics" do @@ -97,7 +97,7 @@ describe Azure::Storage::Blob::BlobService do properties.minute_metrics.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end it "without retention" do @@ -112,7 +112,7 @@ describe Azure::Storage::Blob::BlobService do properties.minute_metrics.retention_policy.days = 10 result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end end @@ -133,14 +133,14 @@ describe Azure::Storage::Blob::BlobService do properties.cors = Azure::Storage::Common::Service::Cors.new result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil end it "sets CORS rules" do cors_properties.cors.cors_rules.push cors_rule result = subject.set_service_properties cors_properties - result.must_be_nil + _(result).must_be_nil end it "sets CORS with duplicated rules" do @@ -148,7 +148,7 @@ describe Azure::Storage::Blob::BlobService do cors_properties.cors.cors_rules.push cors_rule result = subject.set_service_properties cors_properties - result.must_be_nil + _(result).must_be_nil end it "sets CORS rules without allowed_origins" do @@ -206,7 +206,7 @@ describe Azure::Storage::Blob::BlobService do cors_properties.cors.cors_rules.push cors_rule result = subject.set_service_properties cors_properties - result.must_be_nil + _(result).must_be_nil end it "sets CORS rules without allowed_headers" do @@ -224,7 +224,7 @@ describe Azure::Storage::Blob::BlobService do cors_properties.cors.cors_rules.push cors_rule result = subject.set_service_properties cors_properties - result.must_be_nil + _(result).must_be_nil end end end @@ -257,38 +257,38 @@ describe Azure::Storage::Blob::BlobService do properties.cors.cors_rules.push rule result = subject.set_service_properties properties - result.must_be_nil + _(result).must_be_nil sleep(5.0) # Wait for the setting being effective result = subject.get_service_properties - result.logging.wont_be_nil - result.logging.version.must_equal "1.0" + _(result.logging).wont_be_nil + _(result.logging.version).must_equal "1.0" result.logging.delete = false result.logging.read = true result.logging.write = true - result.logging.retention_policy.enabled.must_equal true - result.logging.retention_policy.days.must_equal 2 - - result.hour_metrics.version.must_equal "1.0" - result.hour_metrics.enabled.must_equal true - result.hour_metrics.retention_policy.enabled.must_equal false - - result.minute_metrics.version.must_equal "1.0" - result.minute_metrics.enabled.must_equal true - result.minute_metrics.include_apis.must_equal true - result.minute_metrics.retention_policy.enabled.must_equal true - result.minute_metrics.retention_policy.days.must_equal 4 - - result.cors.cors_rules.length.must_equal 1 - result.cors.cors_rules[0].allowed_origins.must_include "www.cd.com" - result.cors.cors_rules[0].allowed_origins.must_include "www.ef.com" - result.cors.cors_rules[0].allowed_methods.must_include "GET" - result.cors.cors_rules[0].allowed_methods.must_include "PUT" - result.cors.cors_rules[0].exposed_headers.must_include "x-ms-meta-data*" - result.cors.cors_rules[0].exposed_headers.must_include "x-ms-meta-abc" - result.cors.cors_rules[0].allowed_headers.must_include "x-ms-meta-target*" - result.cors.cors_rules[0].allowed_headers.must_include "x-ms-meta-xyz" - result.cors.cors_rules[0].max_age_in_seconds.must_equal rule.max_age_in_seconds + _(result.logging.retention_policy.enabled).must_equal true + _(result.logging.retention_policy.days).must_equal 2 + + _(result.hour_metrics.version).must_equal "1.0" + _(result.hour_metrics.enabled).must_equal true + _(result.hour_metrics.retention_policy.enabled).must_equal false + + _(result.minute_metrics.version).must_equal "1.0" + _(result.minute_metrics.enabled).must_equal true + _(result.minute_metrics.include_apis).must_equal true + _(result.minute_metrics.retention_policy.enabled).must_equal true + _(result.minute_metrics.retention_policy.days).must_equal 4 + + _(result.cors.cors_rules.length).must_equal 1 + _(result.cors.cors_rules[0].allowed_origins).must_include "www.cd.com" + _(result.cors.cors_rules[0].allowed_origins).must_include "www.ef.com" + _(result.cors.cors_rules[0].allowed_methods).must_include "GET" + _(result.cors.cors_rules[0].allowed_methods).must_include "PUT" + _(result.cors.cors_rules[0].exposed_headers).must_include "x-ms-meta-data*" + _(result.cors.cors_rules[0].exposed_headers).must_include "x-ms-meta-abc" + _(result.cors.cors_rules[0].allowed_headers).must_include "x-ms-meta-target*" + _(result.cors.cors_rules[0].allowed_headers).must_include "x-ms-meta-xyz" + _(result.cors.cors_rules[0].max_age_in_seconds).must_equal rule.max_age_in_seconds end end end diff --git a/test/integration/blob/blob_service_stats_test.rb b/test/integration/blob/blob_service_stats_test.rb index 7de49ef1c8ca85bf581401087fed7714156a5356..98aed109ca19103e63edcda98dc5908158230aa9 100644 --- a/test/integration/blob/blob_service_stats_test.rb +++ b/test/integration/blob/blob_service_stats_test.rb @@ -31,9 +31,9 @@ describe Azure::Storage::Blob::BlobService do describe "#get_service_stats" do it "gets service stats" do stats = subject.get_service_stats - stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication - stats.geo_replication.status.must_equal "live" - stats.geo_replication.last_sync_time.must_be_kind_of Time + _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication + _(stats.geo_replication.status).must_equal "live" + _(stats.geo_replication.last_sync_time).must_be_kind_of Time end end end diff --git a/test/integration/blob/block_blob_test.rb b/test/integration/blob/block_blob_test.rb index 4d46cf202381b266bce21eb4949fd12625226d00..740ad41c519cea7cecde32f722f1d02b299482bd 100644 --- a/test/integration/blob/block_blob_test.rb +++ b/test/integration/blob/block_blob_test.rb @@ -40,19 +40,19 @@ describe Azure::Storage::Blob::BlobService do describe "#create_block_blob" do it "creates a block blob" do blob = subject.create_block_blob container_name, blob_name, content - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true blob = subject.get_blob_properties container_name, blob_name - blob.properties[:content_type].must_equal "text/plain; charset=UTF-8" + _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8" end it "creates a block blob with empty content" do temp = subject.clone blob = temp.create_block_blob container_name, blob_name, "" - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true blob = subject.get_blob_properties container_name, blob_name - blob.properties[:content_type].must_equal "application/octet-stream" + _(blob.properties[:content_type]).must_equal "application/octet-stream" end it "creates a block blob with IO" do @@ -62,10 +62,10 @@ describe Azure::Storage::Blob::BlobService do file.seek 0 subject.create_block_blob container_name, blob_name, file blob = subject.get_blob_properties container_name, blob_name - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:content_length].must_equal content.length - blob.properties[:content_type].must_equal "application/octet-stream" + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:content_length]).must_equal content.length + _(blob.properties[:content_type]).must_equal "application/octet-stream" ensure unless file.nil? file.close @@ -81,24 +81,24 @@ describe Azure::Storage::Blob::BlobService do content_50_mb.force_encoding "utf-8" blob_name = BlobNameHelper.name blob = subject.create_block_blob container_name, blob_name, content_50_mb, options - blob.name.must_equal blob_name + _(blob.name).must_equal blob_name # No content length if single upload - blob.properties[:content_length].must_equal 50 * 1024 * 1024 - blob.properties[:content_type].must_equal "text/plain; charset=UTF-8" + _(blob.properties[:content_length]).must_equal 50 * 1024 * 1024 + _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8" end it "should create a block blob with spaces in name" do blob_name = "blob with spaces" blob = subject.create_block_blob container_name, blob_name, "content" - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true end it "should create block blob with complex in name" do blob_name = "with фбаф.txt" blob = subject.create_block_blob container_name, blob_name, "content" - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true end it "sets additional properties when the options hash is used" do @@ -112,17 +112,17 @@ describe Azure::Storage::Blob::BlobService do blob = subject.create_block_blob container_name, blob_name, content, options blob = subject.get_blob_properties container_name, blob_name - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:blob_type].must_equal "BlockBlob" - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:blob_type]).must_equal "BlockBlob" + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" blob = subject.get_blob_metadata container_name, blob_name - blob.name.must_equal blob_name - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(blob.name).must_equal blob_name + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" end it "errors if the container does not exist" do @@ -145,11 +145,11 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works blob = subject.create_block_blob container_name, block_blob_name, content, lease_id: lease_id - blob.name.must_equal block_blob_name + _(blob.name).must_equal block_blob_name end end @@ -163,9 +163,9 @@ describe Azure::Storage::Blob::BlobService do # verify block_list = subject.list_blob_blocks container_name, blob_name block = block_list[:uncommitted][0] - block.type.must_equal :uncommitted - block.size.must_equal 512 - block.name.must_equal blockid1 + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 + _(block.name).must_equal blockid1 end it "creates a 100M block as part of a block blob" do @@ -174,9 +174,9 @@ describe Azure::Storage::Blob::BlobService do # verify block_list = subject.list_blob_blocks container_name, blob_name block = block_list[:uncommitted][0] - block.type.must_equal :uncommitted - block.size.must_equal 100 * 1024 * 1024 - block.name.must_equal blockid2 + _(block.type).must_equal :uncommitted + _(block.size).must_equal 100 * 1024 * 1024 + _(block.name).must_equal blockid2 end it "lease id works for put_blob_block" do @@ -193,17 +193,17 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works subject.put_blob_block container_name, block_blob_name, blockid1, content, lease_id: lease_id # verify block_list = subject.list_blob_blocks container_name, block_blob_name block = block_list[:uncommitted][0] - block.type.must_equal :uncommitted - block.size.must_equal 512 - block.name.must_equal blockid1 + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 + _(block.name).must_equal blockid1 end end @@ -221,9 +221,9 @@ describe Azure::Storage::Blob::BlobService do (0..1).each { |i| block = block_list[:uncommitted][i] - block.type.must_equal :uncommitted - block.size.must_equal 512 - block.name.must_equal blocklist[i][0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 + _(block.name).must_equal blocklist[i][0] } assert_raises(Azure::Core::Http::HTTPError) do @@ -232,13 +232,13 @@ describe Azure::Storage::Blob::BlobService do # commit blocks result = subject.commit_blob_blocks container_name, blob_name, blocklist - result.must_be_nil + _(result).must_be_nil blob, returned_content = subject.get_blob container_name, blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:content_length].must_equal (content.length * 2) - blob.properties[:content_type].must_equal "application/octet-stream" - returned_content.must_equal (content + content) + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:content_length]).must_equal (content.length * 2) + _(blob.properties[:content_type]).must_equal "application/octet-stream" + _(returned_content).must_equal (content + content) end it "lease id works for commit_blob_blocks" do @@ -252,9 +252,9 @@ describe Azure::Storage::Blob::BlobService do (0..1).each { |i| block = block_list[:uncommitted][i] - block.type.must_equal :uncommitted - block.size.must_equal 512 - block.name.must_equal blocklist[i][0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 + _(block.name).must_equal blocklist[i][0] } # acquire lease for blob @@ -269,16 +269,16 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works result = subject.commit_blob_blocks container_name, block_blob_name, blocklist, lease_id: lease_id - result.must_be_nil + _(result).must_be_nil blob, returned_content = subject.get_blob container_name, block_blob_name - is_boolean(blob.encrypted).must_equal true - blob.properties[:content_length].must_equal (content.length * 2) - returned_content.must_equal (content + content) + _(is_boolean(blob.encrypted)).must_equal true + _(blob.properties[:content_length]).must_equal (content.length * 2) + _(returned_content).must_equal (content + content) end end @@ -291,7 +291,7 @@ describe Azure::Storage::Blob::BlobService do # two committed blocks, two uncommitted blocks result = subject.commit_blob_blocks container_name, blob_name, blocklist.slice(0..1) - result.must_be_nil + _(result).must_be_nil subject.put_blob_block container_name, blob_name, blocklist[2][0], content subject.put_blob_block container_name, blob_name, blocklist[3][0], content @@ -301,25 +301,25 @@ describe Azure::Storage::Blob::BlobService do result = subject.list_blob_blocks container_name, blob_name committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } uncommitted = result[:uncommitted] - uncommitted.length.must_equal 2 + _(uncommitted.length).must_equal 2 expected_blocks = blocklist.slice(2..3).each uncommitted.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :uncommitted - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 } end @@ -332,7 +332,7 @@ describe Azure::Storage::Blob::BlobService do subject.put_blob_block container_name, block_blob_name, blocklist[1][0], content result = subject.commit_blob_blocks container_name, block_blob_name, blocklist.slice(0..1) - result.must_be_nil + _(result).must_be_nil subject.put_blob_block container_name, block_blob_name, blocklist[2][0], content subject.put_blob_block container_name, block_blob_name, blocklist[3][0], content @@ -351,56 +351,56 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert correct lease works result = subject.list_blob_blocks container_name, block_blob_name, lease_id: new_lease_id committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } uncommitted = result[:uncommitted] - uncommitted.length.must_equal 2 + _(uncommitted.length).must_equal 2 expected_blocks = blocklist.slice(2..3).each uncommitted.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :uncommitted - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 } # assert no lease works result = subject.list_blob_blocks container_name, block_blob_name committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } uncommitted = result[:uncommitted] - uncommitted.length.must_equal 2 + _(uncommitted.length).must_equal 2 expected_blocks = blocklist.slice(2..3).each uncommitted.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :uncommitted - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 } end @@ -409,17 +409,17 @@ describe Azure::Storage::Blob::BlobService do result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :uncommitted committed = result[:committed] - committed.length.must_equal 0 + _(committed.length).must_equal 0 uncommitted = result[:uncommitted] - uncommitted.length.must_equal 2 + _(uncommitted.length).must_equal 2 expected_blocks = blocklist.slice(2..3).each uncommitted.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :uncommitted - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 } end @@ -427,43 +427,43 @@ describe Azure::Storage::Blob::BlobService do result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :committed committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } uncommitted = result[:uncommitted] - uncommitted.length.must_equal 0 + _(uncommitted.length).must_equal 0 end it "lists committed and uncommitted blocks if :all is passed" do result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :all committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } uncommitted = result[:uncommitted] - uncommitted.length.must_equal 2 + _(uncommitted.length).must_equal 2 expected_blocks = blocklist.slice(2..3).each uncommitted.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :uncommitted - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :uncommitted + _(block.size).must_equal 512 } end end @@ -473,35 +473,35 @@ describe Azure::Storage::Blob::BlobService do snapshot = subject.create_blob_snapshot container_name, blob_name result = subject.commit_blob_blocks container_name, blob_name, blocklist - result.must_be_nil + _(result).must_be_nil result = subject.list_blob_blocks container_name, blob_name committed = result[:committed] - committed.length.must_equal 4 + _(committed.length).must_equal 4 expected_blocks = blocklist.each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :all, snapshot: snapshot committed = result[:committed] - committed.length.must_equal 2 + _(committed.length).must_equal 2 expected_blocks = blocklist.slice(0..1).each committed.each { |block| - block.name.must_equal expected_blocks.next[0] - block.type.must_equal :committed - block.size.must_equal 512 + _(block.name).must_equal expected_blocks.next[0] + _(block.type).must_equal :committed + _(block.size).must_equal 512 } # uncommitted blobs aren't copied in a snapshot. uncommitted = result[:uncommitted] - uncommitted.length.must_equal 0 + _(uncommitted.length).must_equal 0 end end end diff --git a/test/integration/blob/container/container_acl_test.rb b/test/integration/blob/container/container_acl_test.rb index 9dc334042f32f2a1dc604a04e811af6b5cbd5f5a..e8ed1eaa89bc2bd7c57495c2f607e02a11d6c882 100644 --- a/test/integration/blob/container/container_acl_test.rb +++ b/test/integration/blob/container/container_acl_test.rb @@ -43,24 +43,24 @@ describe Azure::Storage::Blob::BlobService do container_name = ContainerNameHelper.name subject.create_container container_name container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers - container.wont_be_nil - container.name.must_equal container_name - container.public_access_level.must_equal public_access_level.to_s - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.public_access_level).must_equal public_access_level.to_s + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission container, acl = subject.get_container_acl container_name - container.wont_be_nil - container.name.must_equal container_name - container.public_access_level.must_equal public_access_level.to_s - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.public_access_level).must_equal public_access_level.to_s + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission end it "errors if the container does not exist" do @@ -88,28 +88,28 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds container, acl = subject.get_container_acl container_name, lease_id: new_lease_id - container.wont_be_nil - container.name.must_equal container_name - container.public_access_level.must_equal public_access_level.to_s - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.public_access_level).must_equal public_access_level.to_s + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission # assert no lease succeeds container, acl = subject.get_container_acl container_name - container.wont_be_nil - container.name.must_equal container_name - container.public_access_level.must_equal public_access_level.to_s - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.public_access_level).must_equal public_access_level.to_s + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission # release lease afterwards subject.release_container_lease container_name, new_lease_id end @@ -129,19 +129,19 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers, lease_id: new_lease_id container, acl = subject.get_container_acl container_name, lease_id: new_lease_id - container.wont_be_nil - container.name.must_equal container_name - container.public_access_level.must_equal public_access_level.to_s - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.public_access_level).must_equal public_access_level.to_s + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission # prove that no lease succeeds container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers, lease_id: new_lease_id # release lease afterwards diff --git a/test/integration/blob/container/container_metadata_test.rb b/test/integration/blob/container/container_metadata_test.rb index db0140c98d4cbe990735acfb065d598f8b90bffe..673d8a1a0c03813e398309efdd7fce59a59f03bc 100644 --- a/test/integration/blob/container/container_metadata_test.rb +++ b/test/integration/blob/container/container_metadata_test.rb @@ -40,13 +40,13 @@ describe Azure::Storage::Blob::BlobService do container_name = ContainerNameHelper.name subject.create_container container_name result = subject.set_container_metadata container_name, metadata - result.must_be_nil + _(result).must_be_nil container = subject.get_container_metadata container_name - container.wont_be_nil - container.name.must_equal container_name + _(container).wont_be_nil + _(container.name).must_equal container_name metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } end @@ -75,22 +75,22 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds container = subject.get_container_metadata container_name, lease_id: new_lease_id - container.wont_be_nil - container.name.must_equal container_name + _(container).wont_be_nil + _(container.name).must_equal container_name metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } # assert no lease succeeds container = subject.get_container_metadata container_name - container.wont_be_nil + _(container).wont_be_nil metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } # release lease afterwards subject.release_container_lease container_name, new_lease_id @@ -111,17 +111,17 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds result = subject.set_container_metadata container_name, metadata, lease_id: new_lease_id - result.must_be_nil + _(result).must_be_nil container = subject.get_container_metadata container_name - container.wont_be_nil - container.name.must_equal container_name + _(container).wont_be_nil + _(container.name).must_equal container_name metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } # prove that no lease succeeds result = subject.set_container_metadata container_name, metadata diff --git a/test/integration/blob/container/create_container_test.rb b/test/integration/blob/container/create_container_test.rb index 3777221b6d310e086052ff5a3dd8089d7e24cfa9..58f1744c0660af31c92ce21eb3652c960001a9e1 100644 --- a/test/integration/blob/container/create_container_test.rb +++ b/test/integration/blob/container/create_container_test.rb @@ -33,7 +33,7 @@ describe Azure::Storage::Blob::BlobService do it "creates the container" do container = subject.create_container container_name - container.name.must_equal container_name + _(container.name).must_equal container_name end it "creates the container with custom metadata" do @@ -41,13 +41,13 @@ describe Azure::Storage::Blob::BlobService do container = subject.create_container container_name, metadata: metadata - container.name.must_equal container_name - container.metadata.must_equal metadata + _(container.name).must_equal container_name + _(container.metadata).must_equal metadata container = subject.get_container_metadata container_name metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/blob/container/delete_container_test.rb b/test/integration/blob/container/delete_container_test.rb index 9d88a19dee2737ddb718c1669c7b1ea8969cdead..7b37bfc208359cbacbd989e4d5909a6baa69c956 100644 --- a/test/integration/blob/container/delete_container_test.rb +++ b/test/integration/blob/container/delete_container_test.rb @@ -33,7 +33,7 @@ describe Azure::Storage::Blob::BlobService do container_name = ContainerNameHelper.name subject.create_container container_name result = subject.delete_container container_name - result.must_be_nil + _(result).must_be_nil end it "errors if the container does not exist" do @@ -57,8 +57,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds subject.delete_container container_name, lease_id: new_lease_id end diff --git a/test/integration/blob/container/get_container_properties_test.rb b/test/integration/blob/container/get_container_properties_test.rb index 5735f7896587a24df87dfb3a31b208c2ba847aa6..4674e38074cac6845902c84e0d43a89a2c1f0fa4 100644 --- a/test/integration/blob/container/get_container_properties_test.rb +++ b/test/integration/blob/container/get_container_properties_test.rb @@ -38,15 +38,15 @@ describe Azure::Storage::Blob::BlobService do properties = container.properties container = subject.get_container_properties container_name - container.wont_be_nil - container.name.must_equal container_name - container.properties[:etag].must_equal properties[:etag] - container.properties[:last_modified].must_equal properties[:last_modified] - container.public_access_level.must_equal "blob" + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.properties[:etag]).must_equal properties[:etag] + _(container.properties[:last_modified]).must_equal properties[:last_modified] + _(container.public_access_level).must_equal "blob" metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } end @@ -72,31 +72,31 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the container." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the container." # assert right lease succeeds container = subject.get_container_properties container_name, lease_id: new_lease_id - container.wont_be_nil - container.name.must_equal container_name - container.properties[:etag].must_equal properties[:etag] - container.properties[:last_modified].must_equal properties[:last_modified] - container.public_access_level.must_equal "blob" + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.properties[:etag]).must_equal properties[:etag] + _(container.properties[:last_modified]).must_equal properties[:last_modified] + _(container.public_access_level).must_equal "blob" metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } # assert no lease succeeds container = subject.get_container_properties container_name - container.wont_be_nil - container.name.must_equal container_name - container.properties[:etag].must_equal properties[:etag] - container.properties[:last_modified].must_equal properties[:last_modified] - container.public_access_level.must_equal "blob" + _(container).wont_be_nil + _(container.name).must_equal container_name + _(container.properties[:etag]).must_equal properties[:etag] + _(container.properties[:last_modified]).must_equal properties[:last_modified] + _(container.public_access_level).must_equal "blob" metadata.each { |k, v| - container.metadata.must_include k.downcase - container.metadata[k.downcase].must_equal v + _(container.metadata).must_include k.downcase + _(container.metadata[k.downcase]).must_equal v } # release lease afterwards subject.release_container_lease container_name, new_lease_id diff --git a/test/integration/blob/container/list_containers_test.rb b/test/integration/blob/container/list_containers_test.rb index a209e8e57b08bad14503fa8e93dfba28e103ba22..897491031ca153f4a778c9f4dffe919a78106dba 100644 --- a/test/integration/blob/container/list_containers_test.rb +++ b/test/integration/blob/container/list_containers_test.rb @@ -44,9 +44,9 @@ describe Azure::Storage::Blob::BlobService do found = 0 result.each { |c| found += 1 if container_names.include? c.name - c.public_access_level.must_equal "blob" if container_names.include? c.name + _(c.public_access_level).must_equal "blob" if container_names.include? c.name } - found.must_equal container_names.length + _(found).must_equal container_names.length end it "lists the containers for the account with prefix" do @@ -55,20 +55,20 @@ describe Azure::Storage::Blob::BlobService do found = 0 result.each { |c| found += 1 if container_names.include? c.name - c.public_access_level.must_equal "blob" if container_names.include? c.name + _(c.public_access_level).must_equal "blob" if container_names.include? c.name } - found.must_equal 1 + _(found).must_equal 1 end it "lists the containers for the account with max results" do result = subject.list_containers(max_results: 1) - result.length.must_equal 1 + _(result.length).must_equal 1 first_container = result[0] result.continuation_token.wont_equal("") result = subject.list_containers(max_results: 1, marker: result.continuation_token) - result.length.must_equal 1 + _(result.length).must_equal 1 result[0].name.wont_equal first_container.name end @@ -80,13 +80,13 @@ describe Azure::Storage::Blob::BlobService do if container_names.include? c.name found += 1 metadata.each { |k, v| - c.metadata.must_include k.downcase - c.metadata[k.downcase].must_equal v + _(c.metadata).must_include k.downcase + _(c.metadata[k.downcase]).must_equal v } - c.public_access_level.must_equal "blob" + _(c.public_access_level).must_equal "blob" end } - found.must_equal container_names.length + _(found).must_equal container_names.length end end end diff --git a/test/integration/blob/container/root_container_test.rb b/test/integration/blob/container/root_container_test.rb index bf1ddf71838d4491c9c9ca1a2511d6959e4bb078..07ffc13f580fd4eeadf3356bcc1cbd44f0e331eb 100644 --- a/test/integration/blob/container/root_container_test.rb +++ b/test/integration/blob/container/root_container_test.rb @@ -43,21 +43,21 @@ describe Azure::Storage::Blob::BlobService do it "creates the container with explicit name and some blobs" do begin container = subject.create_container container_name - container.name.must_equal container_name + _(container.name).must_equal container_name # explicit root container name blob = subject.create_page_blob container_name, blob_name1, length - blob.name.must_equal blob_name1 + _(blob.name).must_equal blob_name1 # nil container name blob = subject.create_page_blob nil, blob_name2, length - blob.name.must_equal blob_name2 + _(blob.name).must_equal blob_name2 # empty string container name blob = subject.create_page_blob "", blob_name3, length - blob.name.must_equal blob_name3 + _(blob.name).must_equal blob_name3 rescue Azure::Core::Http::HTTPError => error puts error.message - error.status_code.must_equal 409 + _(error.status_code).must_equal 409 end end end diff --git a/test/integration/blob/copy_blob_test.rb b/test/integration/blob/copy_blob_test.rb index 76543f9588a33f3dab1b5675f7b2f103efa1d110..7c6b3fcd6b64e17108642804794287847ed6007d 100644 --- a/test/integration/blob/copy_blob_test.rb +++ b/test/integration/blob/copy_blob_test.rb @@ -45,49 +45,49 @@ describe Azure::Storage::Blob::BlobService do it "copies an existing blob to a new storage location" do copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil blob, returned_content = subject.get_blob dest_container_name, dest_blob_name - blob.name.must_equal dest_blob_name - returned_content.must_equal content + _(blob.name).must_equal dest_blob_name + _(returned_content).must_equal content end it "returns a copyid which can be used to monitor status of the asynchronous copy operation" do copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil counter = 0 finished = false while (counter < (10) && (not finished)) sleep(1) blob = subject.get_blob_properties dest_container_name, dest_blob_name - blob.properties[:copy_id].must_equal copy_id + _(blob.properties[:copy_id]).must_equal copy_id finished = blob.properties[:copy_status] == "success" counter += 1 end - finished.must_equal true + _(finished).must_equal true blob, returned_content = subject.get_blob dest_container_name, dest_blob_name - blob.name.must_equal dest_blob_name - returned_content.must_equal content + _(blob.name).must_equal dest_blob_name + _(returned_content).must_equal content end it "returns a copyid which can be used to abort copy operation" do copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil counter = 0 finished = false while (counter < (10) && (not finished)) sleep(1) blob = subject.get_blob_properties dest_container_name, dest_blob_name - blob.properties[:copy_id].must_equal copy_id + _(blob.properties[:copy_id]).must_equal copy_id finished = blob.properties[:copy_status] == "success" counter += 1 end - finished.must_equal true + _(finished).must_equal true exception = assert_raises(Azure::Core::Http::HTTPError) do subject.abort_copy_blob dest_container_name, dest_blob_name, copy_id @@ -102,7 +102,7 @@ describe Azure::Storage::Blob::BlobService do # verify blob is updated, and content is different than snapshot subject.create_block_blob source_container_name, source_blob_name, content + "more content" blob, returned_content = subject.get_blob source_container_name, source_blob_name - returned_content.must_equal content + "more content" + _(returned_content).must_equal content + "more content" # do copy against, snapshot subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name, source_snapshot: snapshot @@ -110,25 +110,25 @@ describe Azure::Storage::Blob::BlobService do blob, returned_content = subject.get_blob dest_container_name, dest_blob_name # verify copied content is old content - returned_content.must_equal content + _(returned_content).must_equal content end end describe "when a options hash is used" do it "replaces source metadata on the copy with provided Hash in :metadata property" do copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name, metadata: metadata - copy_id.wont_be_nil + _(copy_id).wont_be_nil blob, returned_content = subject.get_blob dest_container_name, dest_blob_name - blob.name.must_equal dest_blob_name - returned_content.must_equal content + _(blob.name).must_equal dest_blob_name + _(returned_content).must_equal content blob = subject.get_blob_metadata dest_container_name, dest_blob_name metadata.each { |k, v| - blob.metadata.must_include k - blob.metadata[k].must_equal v + _(blob.metadata).must_include k + _(blob.metadata[k]).must_equal v } end @@ -154,14 +154,14 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works copy_id, copy_status = subject.copy_blob dest_container_name, blob_name, source_container_name, source_blob_name, lease_id: lease_id - copy_id.wont_be_nil + _(copy_id).wont_be_nil blob, returned_content = subject.get_blob dest_container_name, blob_name - blob.name.must_equal blob_name - returned_content.must_equal content + _(blob.name).must_equal blob_name + _(returned_content).must_equal content end end end diff --git a/test/integration/blob/create_blob_snapshot_test.rb b/test/integration/blob/create_blob_snapshot_test.rb index 7caeee6229426fd3a0e27b649f64f68b1534ba1f..3c4c90c011f4fa0c62adf57ff1fdf5ea3558b264 100644 --- a/test/integration/blob/create_blob_snapshot_test.rb +++ b/test/integration/blob/create_blob_snapshot_test.rb @@ -65,23 +65,23 @@ describe Azure::Storage::Blob::BlobService do # content/properties/metadata in blob is new version blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511 - returned_content.length.must_equal 512 - returned_content.must_equal content2[0..511] - blob.properties[:content_type].must_equal options2[:content_type] + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content2[0..511] + _(blob.properties[:content_type]).must_equal options2[:content_type] options2[:metadata].each { |k, v| - blob.metadata.must_include k.downcase - blob.metadata[k.downcase].must_equal v + _(blob.metadata).must_include k.downcase + _(blob.metadata[k.downcase]).must_equal v } # content/properties/metadata in snapshot is old version blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, snapshot: snapshot - returned_content.length.must_equal 512 - returned_content.must_equal content[0..511] - blob.properties[:content_type].must_equal options[:content_type] + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content[0..511] + _(blob.properties[:content_type]).must_equal options[:content_type] options[:metadata].each { |k, v| - blob.metadata.must_include k.downcase - blob.metadata[k.downcase].must_equal v + _(blob.metadata).must_include k.downcase + _(blob.metadata[k.downcase]).must_equal v } end @@ -102,14 +102,14 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert right lease succeeds snapshot = subject.create_blob_snapshot container_name, page_blob_name, lease_id: new_lease_id - snapshot.wont_be_nil + _(snapshot).wont_be_nil # assert no lease succeeds snapshot = subject.create_blob_snapshot container_name, page_blob_name - snapshot.wont_be_nil + _(snapshot).wont_be_nil end end end diff --git a/test/integration/blob/create_page_blob_test.rb b/test/integration/blob/create_page_blob_test.rb index 59608648e1d39e0b62110f503e2364badff34b63..1ceb9578cf3a7db49182f0c585a14813b825f642 100644 --- a/test/integration/blob/create_page_blob_test.rb +++ b/test/integration/blob/create_page_blob_test.rb @@ -39,22 +39,22 @@ describe Azure::Storage::Blob::BlobService do it "creates a page blob" do blob = subject.create_page_blob container_name, blob_name, length - blob.name.must_equal blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal blob_name + _(is_boolean(blob.encrypted)).must_equal true blob = subject.get_blob_properties container_name, blob_name - blob.properties[:content_type].must_equal "application/octet-stream" + _(blob.properties[:content_type]).must_equal "application/octet-stream" end it "creates page blob with non uri encoded path" do blob = subject.create_page_blob container_name, "фбаф.jpg", length - blob.name.must_equal "фбаф.jpg" - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal "фбаф.jpg" + _(is_boolean(blob.encrypted)).must_equal true end it "creates a page blob with complex name" do blob = subject.create_page_blob container_name, complex_blob_name, length - blob.name.must_equal complex_blob_name - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal complex_blob_name + _(is_boolean(blob.encrypted)).must_equal true complex_blob_name.force_encoding("UTF-8") found_complex_name = false @@ -63,7 +63,7 @@ describe Azure::Storage::Blob::BlobService do found_complex_name = true if blob.name == complex_blob_name } - found_complex_name.must_equal true + _(found_complex_name).must_equal true end it "sets additional properties when the options hash is used" do @@ -77,17 +77,17 @@ describe Azure::Storage::Blob::BlobService do blob = subject.create_page_blob container_name, blob_name, length, options blob = subject.get_blob_properties container_name, blob_name - is_boolean(blob.encrypted).must_equal true - blob.name.must_equal blob_name - blob.properties[:blob_type].must_equal "PageBlob" - blob.properties[:content_type].must_equal options[:content_type] - blob.properties[:content_encoding].must_equal options[:content_encoding] - blob.properties[:cache_control].must_equal options[:cache_control] - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(is_boolean(blob.encrypted)).must_equal true + _(blob.name).must_equal blob_name + _(blob.properties[:blob_type]).must_equal "PageBlob" + _(blob.properties[:content_type]).must_equal options[:content_type] + _(blob.properties[:content_encoding]).must_equal options[:content_encoding] + _(blob.properties[:cache_control]).must_equal options[:cache_control] + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" blob = subject.get_blob_metadata container_name, blob_name - blob.name.must_equal blob_name - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" + _(blob.name).must_equal blob_name + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" end it "errors if the container does not exist" do @@ -116,11 +116,11 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works blob = subject.create_page_blob container_name, page_blob_name, length, lease_id: lease_id - blob.name.must_equal page_blob_name + _(blob.name).must_equal page_blob_name end end end diff --git a/test/integration/blob/delete_blob_test.rb b/test/integration/blob/delete_blob_test.rb index 095f20ca0d88061c6a210b6c4c94823e7f5dfdb2..4c3e4c13608231e756a9c282faddf4630b315535 100644 --- a/test/integration/blob/delete_blob_test.rb +++ b/test/integration/blob/delete_blob_test.rb @@ -67,8 +67,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "There is currently a lease on the blob and no lease ID was specified in the request." + _(status_code).must_equal "412" + _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request." # assert correct lease works subject.delete_blob container_name, page_blob_name, lease_id: lease_id end @@ -89,14 +89,14 @@ describe Azure::Storage::Blob::BlobService do result.each { |b| snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot) } - snapshot_exists.must_equal true + _(snapshot_exists).must_equal true # delete blob subject.delete_blob container_name, blob_name # verify blob is gone and snapshot remains result = subject.list_blobs(container_name, snapshots: true) - result.length.must_equal 0 + _(result.length).must_equal 0 end it "the snapshot parameter deletes a specific blob snapshot" do @@ -111,7 +111,7 @@ describe Azure::Storage::Blob::BlobService do result.each { |b| snapshots += 1 if b.name == (blob_name) && b.snapshot != (nil) } - snapshots.must_equal 2 + _(snapshots).must_equal 2 subject.delete_blob container_name, blob_name, snapshot: snapshot @@ -124,8 +124,8 @@ describe Azure::Storage::Blob::BlobService do blob_exists = true if b.name == (blob_name) && b.snapshot == (nil) snapshots += 1 if b.name == (blob_name) && b.snapshot == (second_snapshot) } - blob_exists.must_equal true - snapshots.must_equal 1 + _(blob_exists).must_equal true + _(snapshots).must_equal 1 end it "errors if the snapshot id provided does not exist" do @@ -144,7 +144,7 @@ describe Azure::Storage::Blob::BlobService do result.each { |b| snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot) } - snapshot_exists.must_equal true + _(snapshot_exists).must_equal true # delete snapshots subject.delete_blob container_name, blob_name, snapshot: nil, delete_snapshots: :only @@ -158,8 +158,8 @@ describe Azure::Storage::Blob::BlobService do blob_exists = true if b.name == (blob_name) && b.snapshot == (nil) snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot) } - blob_exists.must_equal true - snapshot_exists.must_equal false + _(blob_exists).must_equal true + _(snapshot_exists).must_equal false end end @@ -173,14 +173,14 @@ describe Azure::Storage::Blob::BlobService do result.each { |b| snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot) } - snapshot_exists.must_equal true + _(snapshot_exists).must_equal true # delete snapshots subject.delete_blob container_name, blob_name, snapshot: nil, delete_snapshots: :include # verify snapshot is gone and blob remains result = subject.list_blobs(container_name, snapshots: true) - result.length.must_equal 0 + _(result.length).must_equal 0 end end end diff --git a/test/integration/blob/get_blob_test.rb b/test/integration/blob/get_blob_test.rb index 92b5ba5b3ac48d6149cbcf2bf073eb79d3b872b1..463a55b7b0289e0e493e470e0935cf9255428fd2 100644 --- a/test/integration/blob/get_blob_test.rb +++ b/test/integration/blob/get_blob_test.rb @@ -44,19 +44,19 @@ describe Azure::Storage::Blob::BlobService do it "retrieves the blob properties, metadata, and contents" do blob, returned_content = subject.get_blob container_name, blob_name - returned_content.must_equal content - blob.metadata.must_include "custommetadataproperty" - blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" - blob.properties[:content_type].must_equal "application/foo" + _(returned_content).must_equal content + _(blob.metadata).must_include "custommetadataproperty" + _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" + _(blob.properties[:content_type]).must_equal "application/foo" end it "retrieves a range of data from the blob" do blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, get_content_md5: true - is_boolean(blob.encrypted).must_equal true - returned_content.length.must_equal 512 - returned_content.must_equal content[0..511] - blob.properties[:range_md5].must_equal Digest::MD5.base64digest(content[0..511]) - blob.properties[:content_md5].must_equal Digest::MD5.base64digest(content) + _(is_boolean(blob.encrypted)).must_equal true + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content[0..511] + _(blob.properties[:range_md5]).must_equal Digest::MD5.base64digest(content[0..511]) + _(blob.properties[:content_md5]).must_equal Digest::MD5.base64digest(content) end it "retrieves a snapshot of data from the blob" do @@ -67,15 +67,15 @@ describe Azure::Storage::Blob::BlobService do subject.create_block_blob container_name, blob_name, content2, options blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511 - is_boolean(blob.encrypted).must_equal true - returned_content.length.must_equal 512 - returned_content.must_equal content2[0..511] + _(is_boolean(blob.encrypted)).must_equal true + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content2[0..511] blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, snapshot: snapshot - is_boolean(blob.encrypted).must_equal true + _(is_boolean(blob.encrypted)).must_equal true - returned_content.length.must_equal 512 - returned_content.must_equal content[0..511] + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content[0..511] end it "read failure with if_none_match: *" do @@ -87,8 +87,8 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "400" - description.must_include "The request includes an unsatisfiable condition for this operation." + _(status_code).must_equal "400" + _(description).must_include "The request includes an unsatisfiable condition for this operation." end it "lease id works for get_blob" do @@ -107,16 +107,16 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert correct lease works blob, body = subject.get_blob container_name, block_blob_name, lease_id: new_lease_id - blob.name.must_equal block_blob_name - body.must_equal content + _(blob.name).must_equal block_blob_name + _(body).must_equal content # assert no lease works blob, body = subject.get_blob container_name, block_blob_name - blob.name.must_equal block_blob_name - body.must_equal content + _(blob.name).must_equal block_blob_name + _(body).must_equal content end end end diff --git a/test/integration/blob/incremental_copy_blob_test.rb b/test/integration/blob/incremental_copy_blob_test.rb index 65bc2827391f10ecfbce983d867a41ce3f209cde..3129bd7bfd165751489d3ba2258cfeb044f05077 100644 --- a/test/integration/blob/incremental_copy_blob_test.rb +++ b/test/integration/blob/incremental_copy_blob_test.rb @@ -70,9 +70,9 @@ describe Azure::Storage::Blob::BlobService do it "test incremental snapshot can work" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true end it "test incremental snapshot fails on existing blob" do @@ -81,92 +81,92 @@ describe Azure::Storage::Blob::BlobService do e = assert_raises Azure::Core::Http::HTTPError do subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s end - e.status_code.must_equal 409 - e.type.must_equal "OperationNotAllowedOnIncrementalCopyBlob" + _(e.status_code).must_equal 409 + _(e.type).must_equal "OperationNotAllowedOnIncrementalCopyBlob" end it "test 'if_modified_since' work" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true # test failing case for if_modified_since now = Time.new + 1 e = assert_raises Azure::Core::Http::HTTPError do subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_modified_since: now.httpdate end - e.status_code.must_equal 412 - e.type.must_equal "ConditionNotMet" + _(e.status_code).must_equal 412 + _(e.type).must_equal "ConditionNotMet" now -= 65535 # Should be a long time that makes sense # test success case for if_modified_since copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_modified_since: now.httpdate - copy_id.wont_be_nil + _(copy_id).wont_be_nil end it "test 'if_unmodified_since' work" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true # test failing case for if_unmodified_since now = Time.new - 65535 # Should be a long time that makes sense e = assert_raises Azure::Core::Http::HTTPError do subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_unmodified_since: now.httpdate end - e.status_code.must_equal 412 - e.type.must_equal "ConditionNotMet" + _(e.status_code).must_equal 412 + _(e.type).must_equal "ConditionNotMet" now += 65536 # Should be a long time that makes sense # test success case for if_unmodified_since copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_unmodified_since: now.httpdate - copy_id.wont_be_nil + _(copy_id).wont_be_nil end it "test 'if_match' work" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true etag = blob.properties[:etag] - etag.wont_be_nil + _(etag).wont_be_nil # test failing case for if_match e = assert_raises Azure::Core::Http::HTTPError do subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_match: etag + "blablabla" end - e.status_code.must_equal 412 - e.type.must_equal "TargetConditionNotMet" + _(e.status_code).must_equal 412 + _(e.type).must_equal "TargetConditionNotMet" # test success case for if_match copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_match: etag - copy_id.wont_be_nil + _(copy_id).wont_be_nil end it "test 'if_none_match' work" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true etag = blob.properties[:etag] - etag.wont_be_nil + _(etag).wont_be_nil # test failing case for if_none_match e = assert_raises Azure::Core::Http::HTTPError do subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_none_match: etag end - e.status_code.must_equal 412 - e.type.must_equal "ConditionNotMet" + _(e.status_code).must_equal 412 + _(e.type).must_equal "ConditionNotMet" # test success case for if_none_match copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_none_match: etag + "blablabla" - copy_id.wont_be_nil + _(copy_id).wont_be_nil end it "lease id works for incremental_copy_blob" do dest_blob_name = BlobNameHelper.name result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s - result[1].must_equal "pending" + _(result[1]).must_equal "pending" blob = subject.get_blob_properties(container_name, dest_blob_name) - blob.properties[:incremental_copy].must_equal true + _(blob.properties[:incremental_copy]).must_equal true # acquire lease for blob lease_id = subject.acquire_blob_lease container_name, dest_blob_name subject.release_blob_lease container_name, dest_blob_name, lease_id @@ -181,11 +181,11 @@ describe Azure::Storage::Blob::BlobService do status_code = e.status_code.to_s description = e.description end - status_code.must_equal "412" - description.must_include "The lease ID specified did not match the lease ID for the blob." + _(status_code).must_equal "412" + _(description).must_include "The lease ID specified did not match the lease ID for the blob." # assert correct lease works copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, lease_id: new_lease_id - copy_id.wont_be_nil + _(copy_id).wont_be_nil end end end diff --git a/test/integration/blob/informative_errors_test.rb b/test/integration/blob/informative_errors_test.rb index 9d5c957eb5a67ca3b38c4490bc363f1034bd3133..e3b1e22b530d149a5c0c45a87650083d0a0ecdbd 100644 --- a/test/integration/blob/informative_errors_test.rb +++ b/test/integration/blob/informative_errors_test.rb @@ -39,9 +39,9 @@ describe Azure::Storage::Blob::BlobService do subject.create_container container_name flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 409 - error.type.must_equal "ContainerAlreadyExists" - error.description.start_with?("The specified container already exists.").must_equal true + _(error.status_code).must_equal 409 + _(error.type).must_equal "ContainerAlreadyExists" + _(error.description.start_with?("The specified container already exists.")).must_equal true end end end diff --git a/test/integration/blob/lease/acquire_lease_test.rb b/test/integration/blob/lease/acquire_lease_test.rb index c5b2939e9afdd1e726f53551f36d2dd459519492..2b7576a82a16ccce090619765058f37155d6619b 100644 --- a/test/integration/blob/lease/acquire_lease_test.rb +++ b/test/integration/blob/lease/acquire_lease_test.rb @@ -37,14 +37,14 @@ describe Azure::Storage::Blob::BlobService do it "should be possible to acquire a container lease" do lease_id = subject.acquire_container_lease container_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil end it "should be possible to acquire a blob lease" do subject.create_page_blob container_name, blob_name, length lease_id = subject.acquire_blob_lease container_name, blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil end end end diff --git a/test/integration/blob/lease/break_lease_test.rb b/test/integration/blob/lease/break_lease_test.rb index 269dda894916a6207c3e601c84e788f90910cd24..9e4908cf82f01933f7dfd9b3e6583f5f8e96bff2 100644 --- a/test/integration/blob/lease/break_lease_test.rb +++ b/test/integration/blob/lease/break_lease_test.rb @@ -37,22 +37,22 @@ describe Azure::Storage::Blob::BlobService do it "should be possible to break a container lease" do lease_id = subject.acquire_container_lease container_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil broken_lease = subject.break_container_lease container_name # lease should be possible to break immediately - broken_lease.must_equal 0 + _(broken_lease).must_equal 0 end it "should be possible to break a blob lease" do subject.create_page_blob container_name, blob_name, length lease_id = subject.acquire_blob_lease container_name, blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil broken_lease = subject.break_blob_lease container_name, blob_name # lease should be possible to break immediately - broken_lease.must_equal 0 + _(broken_lease).must_equal 0 end end end diff --git a/test/integration/blob/lease/change_lease_test.rb b/test/integration/blob/lease/change_lease_test.rb index 255f8536da7f483deca06cc6a8c853902a56b059..e9c5dd4ddf2aa5d989a6cc1f1dfc95654cf87ab6 100644 --- a/test/integration/blob/lease/change_lease_test.rb +++ b/test/integration/blob/lease/change_lease_test.rb @@ -38,26 +38,26 @@ describe Azure::Storage::Blob::BlobService do it "should be possible to change a container lease" do lease_id = subject.acquire_container_lease container_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil new_lease_id = subject.change_container_lease container_name, lease_id, porposed_lease_id - new_lease_id.wont_be_nil + _(new_lease_id).wont_be_nil # changing a lease returns the same lease id - new_lease_id.must_equal porposed_lease_id + _(new_lease_id).must_equal porposed_lease_id end it "should be possible to change a blob lease" do subject.create_page_blob container_name, blob_name, length lease_id = subject.acquire_blob_lease container_name, blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil new_lease_id = subject.change_blob_lease container_name, blob_name, lease_id, porposed_lease_id - new_lease_id.wont_be_nil + _(new_lease_id).wont_be_nil # changing a lease returns the same lease id - new_lease_id.must_equal porposed_lease_id + _(new_lease_id).must_equal porposed_lease_id end end end diff --git a/test/integration/blob/lease/release_lease_test.rb b/test/integration/blob/lease/release_lease_test.rb index 63c3217f932174a9c015afe7c8e7d3ed39e0887f..32178abd325b090cf7d603441c060c0238c2a45d 100644 --- a/test/integration/blob/lease/release_lease_test.rb +++ b/test/integration/blob/lease/release_lease_test.rb @@ -37,22 +37,22 @@ describe Azure::Storage::Blob::BlobService do it "should be possible to release a container lease" do lease_id = subject.acquire_container_lease container_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil lease_released = subject.release_container_lease container_name, lease_id # lease should be possible to release - lease_released.must_be_nil + _(lease_released).must_be_nil end it "should be possible to release a lease" do subject.create_page_blob container_name, blob_name, length lease_id = subject.acquire_blob_lease container_name, blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil lease_released = subject.release_blob_lease container_name, blob_name, lease_id # lease should be possible to release - lease_released.must_be_nil + _(lease_released).must_be_nil end end end diff --git a/test/integration/blob/lease/renew_lease_test.rb b/test/integration/blob/lease/renew_lease_test.rb index 09bdba85f232990b400262e78b1079870d0417cb..b30cd02682cc5a8dd137b8c3a78870f03b94b2bd 100644 --- a/test/integration/blob/lease/renew_lease_test.rb +++ b/test/integration/blob/lease/renew_lease_test.rb @@ -37,26 +37,26 @@ describe Azure::Storage::Blob::BlobService do it "should be possible to renew a lease" do lease_id = subject.acquire_container_lease container_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil new_lease_id = subject.renew_container_lease container_name, lease_id - new_lease_id.wont_be_nil + _(new_lease_id).wont_be_nil # renewing a lease returns the same lease id - new_lease_id.must_equal lease_id + _(new_lease_id).must_equal lease_id end it "should be possible to renew a lease" do subject.create_page_blob container_name, blob_name, length lease_id = subject.acquire_blob_lease container_name, blob_name - lease_id.wont_be_nil + _(lease_id).wont_be_nil new_lease_id = subject.renew_blob_lease container_name, blob_name, lease_id - new_lease_id.wont_be_nil + _(new_lease_id).wont_be_nil # renewing a lease returns the same lease id - new_lease_id.must_equal lease_id + _(new_lease_id).must_equal lease_id end end end diff --git a/test/integration/blob/list_blobs_test.rb b/test/integration/blob/list_blobs_test.rb index de40d21c79aad61072cc331a8527ec1a7178330d..8e3412d78b3b4f5a19f736e09685afacb2ce2559 100644 --- a/test/integration/blob/list_blobs_test.rb +++ b/test/integration/blob/list_blobs_test.rb @@ -44,56 +44,56 @@ describe Azure::Storage::Blob::BlobService do it "lists the available blobs" do result = subject.list_blobs container_name - result.length.must_equal blob_names.length + _(result.length).must_equal blob_names.length expected_blob_names = blob_names.each result.each { |blob| - blob.name.must_equal expected_blob_names.next - blob.properties[:content_length].must_equal content.length - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal expected_blob_names.next + _(blob.properties[:content_length]).must_equal content.length + _(is_boolean(blob.encrypted)).must_equal true } end it "lists the available blobs with prefix" do result = subject.list_blobs container_name, prefix: "blobname0" - result.length.must_equal 1 + _(result.length).must_equal 1 result = subject.list_blobs container_name, prefix: "prefix0/" - result.length.must_equal 3 + _(result.length).must_equal 3 end it "lists the available blobs and prefixes with delimiter and prefix" do result = subject.list_blobs container_name, delimiter: "/" - result.length.must_equal 5 + _(result.length).must_equal 5 result = subject.list_blobs container_name, delimiter: "/", prefix: "prefix0/" - result.length.must_equal 3 + _(result.length).must_equal 3 result = subject.list_blobs container_name, delimiter: "/", prefix: "prefix0/child_prefix0/" - result.length.must_equal 1 + _(result.length).must_equal 1 end it "lists the available blobs with max results and marker " do result = subject.list_blobs container_name, max_results: 2 - result.length.must_equal 2 + _(result.length).must_equal 2 first_blob = result[0] result.continuation_token.wont_equal("") result = subject.list_blobs container_name, max_results: 2, marker: result.continuation_token - result.length.must_equal 2 + _(result.length).must_equal 2 result[0].name.wont_equal first_blob.name end describe "when options hash is used" do it "if :metadata is set true, also returns custom metadata for the blobs" do result = subject.list_blobs container_name, metadata: true - result.length.must_equal blob_names.length + _(result.length).must_equal blob_names.length expected_blob_names = blob_names.each result.each { |blob| - blob.name.must_equal expected_blob_names.next - blob.properties[:content_length].must_equal content.length - is_boolean(blob.encrypted).must_equal true + _(blob.name).must_equal expected_blob_names.next + _(blob.properties[:content_length]).must_equal content.length + _(is_boolean(blob.encrypted)).must_equal true metadata.each { |k, v| - blob.metadata.must_include k.downcase - blob.metadata[k.downcase].must_equal v + _(blob.metadata).must_include k.downcase + _(blob.metadata[k.downcase]).must_equal v } } end @@ -103,15 +103,15 @@ describe Azure::Storage::Blob::BlobService do # verify snapshots aren't returned on a normal call result = subject.list_blobs container_name - result.length.must_equal blob_names.length + _(result.length).must_equal blob_names.length result = subject.list_blobs container_name, snapshots: true - result.length.must_equal blob_names.length + 1 + _(result.length).must_equal blob_names.length + 1 found_snapshot = false result.each { |blob| found_snapshot = true if blob.name == (blob_names[0]) && blob.snapshot == (snapshot) } - found_snapshot.must_equal true + _(found_snapshot).must_equal true end it "if :uncommittedblobs is set true, also returns blobs with uploaded, uncommitted blocks" do @@ -120,15 +120,15 @@ describe Azure::Storage::Blob::BlobService do # verify uncommitted blobs aren't returned on a normal call result = subject.list_blobs container_name - result.length.must_equal blob_names.length + _(result.length).must_equal blob_names.length result = subject.list_blobs container_name, uncommittedblobs: true - result.length.must_equal blob_names.length + 1 + _(result.length).must_equal blob_names.length + 1 found_uncommitted = true result.each { |blob| found_uncommitted = true if blob.name == "blockblobname" } - found_uncommitted.must_equal true + _(found_uncommitted).must_equal true end end end diff --git a/test/integration/file/create_directory_test.rb b/test/integration/file/create_directory_test.rb index eb5bc7d26ae8a7b6f55475edee656074674f7dbd..2f78f609d25d24894f57c284061a58e385cdc784 100644 --- a/test/integration/file/create_directory_test.rb +++ b/test/integration/file/create_directory_test.rb @@ -37,7 +37,7 @@ describe Azure::Storage::File::FileService do it "creates the directory" do directory = subject.create_directory share_name, directory_name - directory.name.must_equal directory_name + _(directory.name).must_equal directory_name end it "creates the directory with custom metadata" do @@ -45,13 +45,13 @@ describe Azure::Storage::File::FileService do directory = subject.create_directory share_name, directory_name, metadata: metadata - directory.name.must_equal directory_name - directory.metadata.must_equal metadata + _(directory.name).must_equal directory_name + _(directory.metadata).must_equal metadata directory = subject.get_directory_metadata share_name, directory_name metadata.each { |k, v| - directory.metadata.must_include k.downcase - directory.metadata[k.downcase].must_equal v + _(directory.metadata).must_include k.downcase + _(directory.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/create_file_test.rb b/test/integration/file/create_file_test.rb index 8e89361fc43dd4820055dec4ce336d1725ef2656..247538b56c17596cee1c900055e5e924734687ef 100644 --- a/test/integration/file/create_file_test.rb +++ b/test/integration/file/create_file_test.rb @@ -44,10 +44,10 @@ describe Azure::Storage::File::FileService do file_name = FileNameHelper.name subject.create_file_from_content share_name, directory_name, file_name, length, content file, body = subject.get_file(share_name, directory_name, file_name) - file.name.must_equal file_name - file.properties[:content_length].must_equal length - file.properties[:content_type].must_equal "text/plain; charset=UTF-8" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(file.name).must_equal file_name + _(file.properties[:content_length]).must_equal length + _(file.properties[:content_type]).must_equal "text/plain; charset=UTF-8" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "4MB string payload works" do @@ -56,10 +56,10 @@ describe Azure::Storage::File::FileService do file_name = FileNameHelper.name subject.create_file_from_content share_name, directory_name, file_name, length, content file, body = subject.get_file(share_name, directory_name, file_name) - file.name.must_equal file_name - file.properties[:content_length].must_equal length - file.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT" - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(file.name).must_equal file_name + _(file.properties[:content_length]).must_equal length + _(file.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT" + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "5MB string payload works" do @@ -68,9 +68,9 @@ describe Azure::Storage::File::FileService do file_name = FileNameHelper.name subject.create_file_from_content share_name, directory_name, file_name, length, content file, body = subject.get_file(share_name, directory_name, file_name) - file.name.must_equal file_name - file.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(file.name).must_equal file_name + _(file.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) end it "IO payload works" do @@ -83,9 +83,9 @@ describe Azure::Storage::File::FileService do local_file.seek 0 subject.create_file_from_content share_name, directory_name, file_name, length, local_file file, body = subject.get_file(share_name, directory_name, file_name) - file.name.must_equal file_name - file.properties[:content_length].must_equal length - Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content) + _(file.name).must_equal file_name + _(file.properties[:content_length]).must_equal length + _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content) ensure unless local_file.nil? local_file.close @@ -107,24 +107,24 @@ describe Azure::Storage::File::FileService do it "creates the file" do file = subject.create_file share_name, directory_name, file_name, file_length - file.name.must_equal file_name + _(file.name).must_equal file_name file = subject.get_file_properties share_name, directory_name, file_name - file.properties[:content_length].must_equal file_length - file.properties[:content_type].must_equal "application/octet-stream" + _(file.properties[:content_length]).must_equal file_length + _(file.properties[:content_type]).must_equal "application/octet-stream" end it "creates the file with custom metadata" do metadata = { "CustomMetadataProperty" => "CustomMetadataValue" } file = subject.create_file share_name, directory_name, file_name, file_length, metadata: metadata - file.name.must_equal file_name - file.metadata.must_equal metadata + _(file.name).must_equal file_name + _(file.metadata).must_equal metadata file = subject.get_file_metadata share_name, directory_name, file_name metadata.each { |k, v| - file.metadata.must_include k.downcase - file.metadata[k.downcase].must_equal v + _(file.metadata).must_include k.downcase + _(file.metadata[k.downcase]).must_equal v } end @@ -132,8 +132,8 @@ describe Azure::Storage::File::FileService do subject.create_file share_name, directory_name, file_name, file_length subject.create_file share_name, directory_name, file_name, file_length + file_length file = subject.get_file_properties share_name, directory_name, file_name - file.name.must_equal file_name - file.properties[:content_length].must_equal file_length * 2 + _(file.name).must_equal file_name + _(file.properties[:content_length]).must_equal file_length * 2 end it "errors if the difilerectory name is invalid" do diff --git a/test/integration/file/create_share_test.rb b/test/integration/file/create_share_test.rb index c01ddd3a79a2d38937e25b2a66f9dbc115225d4c..728921ac5d05020d7e4caab53ea56664395bedcb 100644 --- a/test/integration/file/create_share_test.rb +++ b/test/integration/file/create_share_test.rb @@ -33,20 +33,20 @@ describe Azure::Storage::File::FileService do it "creates the share" do share = subject.create_share share_name - share.name.must_equal share_name + _(share.name).must_equal share_name end it "creates the share with custom metadata" do metadata = { "CustomMetadataProperty" => "CustomMetadataValue" } share = subject.create_share share_name, metadata: metadata - share.name.must_equal share_name - share.metadata.must_equal metadata + _(share.name).must_equal share_name + _(share.metadata).must_equal metadata share = subject.get_share_metadata share_name metadata.each { |k, v| - share.metadata.must_include k.downcase - share.metadata[k.downcase].must_equal v + _(share.metadata).must_include k.downcase + _(share.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/delete_directory_test.rb b/test/integration/file/delete_directory_test.rb index b2d956dfd14571fd43b71880ac551b4d49819bed..8aa6d209faa2943e61fb2868cd0e658401a2bc60 100644 --- a/test/integration/file/delete_directory_test.rb +++ b/test/integration/file/delete_directory_test.rb @@ -39,7 +39,7 @@ describe Azure::Storage::File::FileService do directory = subject.get_directory_properties share_name, directory_name result = subject.delete_directory share_name, directory_name - result.must_be_nil + _(result).must_be_nil assert_raises(Azure::Core::Http::HTTPError) do subject.get_directory_properties share_name, directory_name diff --git a/test/integration/file/delete_file_test.rb b/test/integration/file/delete_file_test.rb index f89dc315ee44447779c0901ed445b050bceb88bc..bb0151034919688ee6a4311bf84d9e7d60a5f8df 100644 --- a/test/integration/file/delete_file_test.rb +++ b/test/integration/file/delete_file_test.rb @@ -40,10 +40,10 @@ describe Azure::Storage::File::FileService do it "deletes the directory" do file = subject.get_file_properties share_name, directory_name, file_name - file.properties[:content_length].must_equal file_length + _(file.properties[:content_length]).must_equal file_length result = subject.delete_file share_name, directory_name, file_name - result.must_be_nil + _(result).must_be_nil assert_raises(Azure::Core::Http::HTTPError) do subject.get_file_properties share_name, directory_name, file_name diff --git a/test/integration/file/delete_share_test.rb b/test/integration/file/delete_share_test.rb index 0c64c9e2d9d263643a142795828ee63aa4115fe2..dcb86753b0b97f01b610de9b994953a3a53e406f 100644 --- a/test/integration/file/delete_share_test.rb +++ b/test/integration/file/delete_share_test.rb @@ -35,10 +35,10 @@ describe Azure::Storage::File::FileService do it "deletes the share" do share = subject.get_share_stats share_name - share.usage.must_equal 0 + _(share.usage).must_equal 0 result = subject.delete_share share_name - result.must_be_nil + _(result).must_be_nil assert_raises(Azure::Core::Http::HTTPError) do subject.get_share_stats share_name diff --git a/test/integration/file/directory_metadata_test.rb b/test/integration/file/directory_metadata_test.rb index ad6804630c4d9146245a69c42e8f68076e8fc0d5..1b7d294062f84927489859246cb624bdb22aa5a4 100644 --- a/test/integration/file/directory_metadata_test.rb +++ b/test/integration/file/directory_metadata_test.rb @@ -43,13 +43,13 @@ describe Azure::Storage::File::FileService do it "sets and gets custom metadata for the directory" do result = subject.set_directory_metadata share_name, directory_name, metadata - result.must_be_nil + _(result).must_be_nil directory = subject.get_directory_metadata share_name, directory_name - directory.wont_be_nil - directory.name.must_equal directory_name + _(directory).wont_be_nil + _(directory.name).must_equal directory_name metadata.each { |k, v| - directory.metadata.must_include k.downcase - directory.metadata[k.downcase].must_equal v + _(directory.metadata).must_include k.downcase + _(directory.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/directory_properties_test.rb b/test/integration/file/directory_properties_test.rb index 55a57834974d8fb5761a194d42749d015ba3ba5b..fce1bd409138f8fc50591fe5d68348d8452e7436 100644 --- a/test/integration/file/directory_properties_test.rb +++ b/test/integration/file/directory_properties_test.rb @@ -40,14 +40,14 @@ describe Azure::Storage::File::FileService do properties = directory.properties directory = subject.get_directory_properties share_name, directory_name - directory.wont_be_nil - directory.name.must_equal directory_name - directory.properties[:etag].must_equal properties[:etag] - directory.properties[:last_modified].must_equal properties[:last_modified] + _(directory).wont_be_nil + _(directory.name).must_equal directory_name + _(directory.properties[:etag]).must_equal properties[:etag] + _(directory.properties[:last_modified]).must_equal properties[:last_modified] metadata.each { |k, v| - directory.metadata.must_include k.downcase - directory.metadata[k.downcase].must_equal v + _(directory.metadata).must_include k.downcase + _(directory.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/file_copy_test.rb b/test/integration/file/file_copy_test.rb index 12e3ba1ffe4267b722a65b0894cfda8f68b0c6ce..8fbed0108a6dd2fe881c0b02220278844c7edf8c 100644 --- a/test/integration/file/file_copy_test.rb +++ b/test/integration/file/file_copy_test.rb @@ -51,59 +51,59 @@ describe Azure::Storage::File::FileService do it "copies an existing file to a new storage location" do copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name - file.name.must_equal dest_file_name - returned_content.must_equal content + _(file.name).must_equal dest_file_name + _(returned_content).must_equal content end it "copies an existing file from URI to a new storage location" do copy_id, copy_status = subject.copy_file_from_uri dest_share_name, dest_directory_name, dest_file_name, source_file_uri - copy_id.wont_be_nil + _(copy_id).wont_be_nil file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name - file.name.must_equal dest_file_name - returned_content.must_equal content + _(file.name).must_equal dest_file_name + _(returned_content).must_equal content end it "returns a copyid which can be used to monitor status of the asynchronous copy operation" do copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil counter = 0 finished = false while (counter < (10) && (not finished)) sleep(1) file = subject.get_file_properties dest_share_name, dest_directory_name, dest_file_name - file.properties[:copy_id].must_equal copy_id + _(file.properties[:copy_id]).must_equal copy_id finished = file.properties[:copy_status] == "success" counter += 1 end - finished.must_equal true + _(finished).must_equal true file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name - file.name.must_equal dest_file_name - returned_content.must_equal content + _(file.name).must_equal dest_file_name + _(returned_content).must_equal content end it "returns a copyid which can be used to abort copy operation" do copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name - copy_id.wont_be_nil + _(copy_id).wont_be_nil counter = 0 finished = false while (counter < (10) && (not finished)) sleep(1) file = subject.get_file_properties dest_share_name, dest_directory_name, dest_file_name - file.properties[:copy_id].must_equal copy_id + _(file.properties[:copy_id]).must_equal copy_id finished = file.properties[:copy_status] == "success" counter += 1 end - finished.must_equal true + _(finished).must_equal true exception = assert_raises(Azure::Core::Http::HTTPError) do subject.abort_copy_file dest_share_name, dest_directory_name, dest_file_name, copy_id @@ -114,16 +114,16 @@ describe Azure::Storage::File::FileService do describe "when a options hash is used" do it "replaces source metadata on the copy with provided Hash in :metadata property" do copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name, metadata: metadata - copy_id.wont_be_nil + _(copy_id).wont_be_nil file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name - file.name.must_equal dest_file_name - returned_content.must_equal content + _(file.name).must_equal dest_file_name + _(returned_content).must_equal content file = subject.get_file_metadata dest_share_name, dest_directory_name, dest_file_name metadata.each { |k, v| - file.metadata.must_include k - file.metadata[k].must_equal v + _(file.metadata).must_include k + _(file.metadata[k]).must_equal v } end end diff --git a/test/integration/file/file_gb18030_test.rb b/test/integration/file/file_gb18030_test.rb index 2087f3d1941234c2c691a2b14284b261d00e5291..e63650372595edc7687c0d116f5702f190409e8b 100644 --- a/test/integration/file/file_gb18030_test.rb +++ b/test/integration/file/file_gb18030_test.rb @@ -78,7 +78,7 @@ describe "File GB-18030" do subject.create_file share_name, directory_name, test_name, file_length files = subject.list_directories_and_files share_name, directory_name files.each { |value| - value.name.must_equal test_name + _(value.name).must_equal test_name } subject.delete_file share_name, directory_name, test_name end @@ -97,7 +97,7 @@ describe "File GB-18030" do subject.create_file share_name, directory_name, test_name, file_length files = subject.list_directories_and_files share_name, directory_name files.each { |value| - value.name.encode("UTF-8").must_equal test_name.encode("UTF-8") + _(value.name.encode("UTF-8")).must_equal test_name.encode("UTF-8") } subject.delete_file share_name, directory_name, test_name end @@ -111,7 +111,7 @@ describe "File GB-18030" do subject.set_file_metadata share_name, directory_name, file_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -123,7 +123,7 @@ describe "File GB-18030" do subject.set_file_metadata share_name, directory_name, file_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -136,7 +136,7 @@ describe "File GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -149,7 +149,7 @@ describe "File GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -161,8 +161,8 @@ describe "File GB-18030" do subject.create_file share_name, directory_name, file_name, content.bytesize subject.put_file_range share_name, directory_name, file_name, 0, content.bytesize - 1, content file, returned_content = subject.get_file share_name, directory_name, file_name - file.properties[:content_type].must_equal "application/octet-stream" - returned_content.force_encoding("UTF-8").must_equal content + _(file.properties[:content_type]).must_equal "application/octet-stream" + _(returned_content.force_encoding("UTF-8")).must_equal content } end @@ -176,7 +176,7 @@ describe "File GB-18030" do file, returned_content = subject.get_file share_name, directory_name, file_name charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end @@ -193,7 +193,7 @@ describe "File GB-18030" do file, returned_content = subject.get_file share_name, directory_name, file_name charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end @@ -210,7 +210,7 @@ describe "File GB-18030" do file, returned_content = subject.get_file share_name, directory_name, file_name charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length] returned_content.force_encoding(charset) - returned_content.must_equal content + _(returned_content).must_equal content } end end diff --git a/test/integration/file/file_metadata_test.rb b/test/integration/file/file_metadata_test.rb index 597ca3e49f50fdd86b295ec97c8da9536e6be8c2..b39379f761d66a0fb3a05ab6cb98b0ca70e698e2 100644 --- a/test/integration/file/file_metadata_test.rb +++ b/test/integration/file/file_metadata_test.rb @@ -46,13 +46,13 @@ describe Azure::Storage::File::FileService do it "sets and gets custom file for the directory" do result = subject.set_file_metadata share_name, directory_name, file_name, metadata - result.must_be_nil + _(result).must_be_nil file = subject.get_file_metadata share_name, directory_name, file_name - file.wont_be_nil - file.name.must_equal file_name + _(file).wont_be_nil + _(file.name).must_equal file_name metadata.each { |k, v| - file.metadata.must_include k.downcase - file.metadata[k.downcase].must_equal v + _(file.metadata).must_include k.downcase + _(file.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/file_properties_test.rb b/test/integration/file/file_properties_test.rb index 8671551dc62e53a11aaaddb5e025c5003455ad85..f190ccf4c5edb005f6746b6c02d95c7844aaf8ad 100644 --- a/test/integration/file/file_properties_test.rb +++ b/test/integration/file/file_properties_test.rb @@ -48,35 +48,35 @@ describe Azure::Storage::File::FileService do it "sets and gets properties for a file" do result = subject.set_file_properties share_name, directory_name, file_name, options - result.must_be_nil + _(result).must_be_nil file = subject.get_file_properties share_name, directory_name, file_name - file.properties[:content_type].must_equal options[:content_type] - file.properties[:content_encoding].must_equal options[:content_encoding] - file.properties[:cache_control].must_equal options[:cache_control] - file.properties[:content_md5].must_equal options[:content_md5] - file.properties[:content_disposition].must_equal options[:content_disposition] + _(file.properties[:content_type]).must_equal options[:content_type] + _(file.properties[:content_encoding]).must_equal options[:content_encoding] + _(file.properties[:cache_control]).must_equal options[:cache_control] + _(file.properties[:content_md5]).must_equal options[:content_md5] + _(file.properties[:content_disposition]).must_equal options[:content_disposition] end it "resize a file" do result = subject.resize_file share_name, directory_name, file_name, file_length + file_length - result.must_be_nil + _(result).must_be_nil file = subject.get_file_properties share_name, directory_name, file_name - file.properties[:content_length].must_equal file_length * 2 + _(file.properties[:content_length]).must_equal file_length * 2 end it "resize a file should not change other properties" do result = subject.set_file_properties share_name, directory_name, file_name, options - result.must_be_nil + _(result).must_be_nil result = subject.resize_file share_name, directory_name, file_name, file_length + file_length - result.must_be_nil + _(result).must_be_nil file = subject.get_file_properties share_name, directory_name, file_name - file.properties[:content_length].must_equal file_length * 2 - file.properties[:content_type].must_equal options[:content_type] - file.properties[:content_encoding].must_equal options[:content_encoding] - file.properties[:cache_control].must_equal options[:cache_control] - file.properties[:content_md5].must_equal options[:content_md5] - file.properties[:content_disposition].must_equal options[:content_disposition] + _(file.properties[:content_length]).must_equal file_length * 2 + _(file.properties[:content_type]).must_equal options[:content_type] + _(file.properties[:content_encoding]).must_equal options[:content_encoding] + _(file.properties[:cache_control]).must_equal options[:cache_control] + _(file.properties[:content_md5]).must_equal options[:content_md5] + _(file.properties[:content_disposition]).must_equal options[:content_disposition] end it "errors if the file name does not exist" do diff --git a/test/integration/file/file_range_test.rb b/test/integration/file/file_range_test.rb index b1294bdb25bdb018b5ffbcfa416fb55987ae6d6a..ea5bb958a95a8a9881e78644331ff014cb9112c7 100644 --- a/test/integration/file/file_range_test.rb +++ b/test/integration/file/file_range_test.rb @@ -48,13 +48,13 @@ describe Azure::Storage::File::FileService do subject.put_file_range share_name, directory_name, file_name, 1024, 1535, content file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 1536 - file.properties[:etag].wont_be_nil - file.properties[:last_modified].wont_be_nil - file.properties[:content_length].must_equal file_length - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 + _(file.properties[:etag]).wont_be_nil + _(file.properties[:last_modified]).wont_be_nil + _(file.properties[:content_length]).must_equal file_length + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 end end @@ -87,13 +87,13 @@ describe Azure::Storage::File::FileService do subject.put_file_range share_name, directory_name, file_name, 2048, 2559, content file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 2560 - ranges.length.must_equal 3 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 - ranges[2][0].must_equal 2048 - ranges[2][1].must_equal 2559 + _(ranges.length).must_equal 3 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 + _(ranges[2][0]).must_equal 2048 + _(ranges[2][1]).must_equal 2559 } describe "when both start_range and end_range are specified" do @@ -101,14 +101,14 @@ describe Azure::Storage::File::FileService do subject.clear_file_range share_name, directory_name, file_name, 512, 1535 file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 2560 - file.properties[:etag].wont_be_nil - file.properties[:last_modified].wont_be_nil - file.properties[:content_length].must_equal file_length - ranges.length.must_equal 2 - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 2048 - ranges[1][1].must_equal 2559 + _(file.properties[:etag]).wont_be_nil + _(file.properties[:last_modified]).wont_be_nil + _(file.properties[:content_length]).must_equal file_length + _(ranges.length).must_equal 2 + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 2048 + _(ranges[1][1]).must_equal 2559 end end end @@ -124,13 +124,13 @@ describe Azure::Storage::File::FileService do it "lists the active file ranges" do file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 1536 - file.properties[:etag].wont_be_nil - file.properties[:last_modified].wont_be_nil - file.properties[:content_length].must_equal file_length - ranges[0][0].must_equal 0 - ranges[0][1].must_equal 511 - ranges[1][0].must_equal 1024 - ranges[1][1].must_equal 1535 + _(file.properties[:etag]).wont_be_nil + _(file.properties[:last_modified]).wont_be_nil + _(file.properties[:content_length]).must_equal file_length + _(ranges[0][0]).must_equal 0 + _(ranges[0][1]).must_equal 511 + _(ranges[1][0]).must_equal 1024 + _(ranges[1][1]).must_equal 1535 end end end diff --git a/test/integration/file/get_file_test.rb b/test/integration/file/get_file_test.rb index 46e4a992ed05d18efa769b02013faa7cf644c1d8..081b6a2be12d2f43c78197c3e297745d85815ce8 100644 --- a/test/integration/file/get_file_test.rb +++ b/test/integration/file/get_file_test.rb @@ -47,18 +47,18 @@ describe Azure::Storage::File::FileService do it "retrieves the file properties, metadata, and contents" do file, returned_content = subject.get_file share_name, directory_name, file_name - returned_content.must_equal content - file.metadata.must_include "custommetadataproperty" - file.metadata["custommetadataproperty"].must_equal "CustomMetadataValue" - file.properties[:content_type].must_equal "application/foo" + _(returned_content).must_equal content + _(file.metadata).must_include "custommetadataproperty" + _(file.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue" + _(file.properties[:content_type]).must_equal "application/foo" end it "retrieves a range of data from the file" do file, returned_content = subject.get_file share_name, directory_name, file_name, start_range: 0, end_range: 511, get_content_md5: true - returned_content.length.must_equal 512 - returned_content.must_equal content[0..511] - file.properties[:range_md5].must_equal Digest::MD5.base64digest(content[0..511]) - file.properties[:content_md5].must_equal full_md5 + _(returned_content.length).must_equal 512 + _(returned_content).must_equal content[0..511] + _(file.properties[:range_md5]).must_equal Digest::MD5.base64digest(content[0..511]) + _(file.properties[:content_md5]).must_equal full_md5 end end end diff --git a/test/integration/file/list_directories_and_files_test.rb b/test/integration/file/list_directories_and_files_test.rb index 973a4614f9db937f3470aba0f9685fcbc6ac578d..e96611e1d4ecd2b2106eff7b8324a331aec1f177 100644 --- a/test/integration/file/list_directories_and_files_test.rb +++ b/test/integration/file/list_directories_and_files_test.rb @@ -51,7 +51,7 @@ describe Azure::Storage::File::FileService do result.each { |directory| found += 1 if directories_names.include? directory.name } - found.must_equal directories_names.length + _(found).must_equal directories_names.length end it "lists the level_2 directories for the account" do @@ -65,17 +65,17 @@ describe Azure::Storage::File::FileService do found += 1 } } - found.must_equal directories_names.length + directories_names.length * sub_directories_names.length + _(found).must_equal directories_names.length + directories_names.length * sub_directories_names.length end it "lists the shares for the account with max results" do result = subject.list_directories_and_files(share_name, nil, max_results: 1) - result.length.must_equal 1 + _(result.length).must_equal 1 first_directory = result[0] result.continuation_token.wont_equal "" result = subject.list_directories_and_files(share_name, nil, max_results: 2, marker: result.continuation_token) - result.length.must_equal 2 + _(result.length).must_equal 2 result[0].name.wont_equal first_directory.name end @@ -89,20 +89,20 @@ describe Azure::Storage::File::FileService do directories_names.each { |name| count += 1 if name.start_with? prefix } - found.must_equal count + _(found).must_equal count end it "lists directories with the directory's name as prefix" do result = subject.list_directories_and_files(share_name, nil, prefix: directories_names[0]) - result.length.must_equal 1 - result.continuation_token.must_equal "" - result[0].name.must_equal directories_names[0] + _(result.length).must_equal 1 + _(result.continuation_token).must_equal "" + _(result[0].name).must_equal directories_names[0] end it "lists directories with a prefix that does not exist" do result = subject.list_directories_and_files(share_name, nil, prefix: directories_names[0] + "nonexistsuffix") - result.length.must_equal 0 - result.continuation_token.must_equal "" + _(result.length).must_equal 0 + _(result.continuation_token).must_equal "" end end @@ -141,8 +141,8 @@ describe Azure::Storage::File::FileService do directory_found += 1 if sub_directories_names.include?(entry.name) && entry.is_a?(Azure::Storage::File::Directory::Directory) file_found += 1 if file_names.include?(entry.name) && entry.is_a?(Azure::Storage::File::File) } - directory_found.must_equal sub_directories_names.length - file_found.must_equal file_names.length + _(directory_found).must_equal sub_directories_names.length + _(file_found).must_equal file_names.length end it "lists the files with prefix" do @@ -155,7 +155,7 @@ describe Azure::Storage::File::FileService do file_names.each { |name| count += 1 if name.start_with? prefix } - found.must_equal count + _(found).must_equal count end end end diff --git a/test/integration/file/list_share_test.rb b/test/integration/file/list_share_test.rb index db72db7f47b2f8c7477f0450dd622a3e25140ad1..847684d21560f02fe899b8fbb7bd065cec60abba 100644 --- a/test/integration/file/list_share_test.rb +++ b/test/integration/file/list_share_test.rb @@ -42,17 +42,17 @@ describe Azure::Storage::File::FileService do result.each { |c| found += 1 if share_names.include? c.name } - found.must_equal share_names.length + _(found).must_equal share_names.length end it "lists the shares for the account with max results" do result = subject.list_shares(max_results: 1) - result.length.must_equal 1 + _(result.length).must_equal 1 first_share = result[0] result.continuation_token.wont_equal("") result = subject.list_shares(max_results: 2, marker: result.continuation_token) - result.length.must_equal 2 + _(result.length).must_equal 2 result[0].name.wont_equal first_share.name end @@ -64,12 +64,12 @@ describe Azure::Storage::File::FileService do if share_names.include? c.name found += 1 metadata.each { |k, v| - c.metadata.must_include k.downcase - c.metadata[k.downcase].must_equal v + _(c.metadata).must_include k.downcase + _(c.metadata[k.downcase]).must_equal v } end } - found.must_equal share_names.length + _(found).must_equal share_names.length end end end diff --git a/test/integration/file/share_acl_test.rb b/test/integration/file/share_acl_test.rb index 7b12f56e6591c7e8d4e7ad259c7b2c5b98c6d533..793c3a4a6258d8872e40b3af1d7797648029aad4 100644 --- a/test/integration/file/share_acl_test.rb +++ b/test/integration/file/share_acl_test.rb @@ -44,22 +44,22 @@ describe Azure::Storage::File::FileService do it "sets and gets the ACL for the share" do share, acl = subject.set_share_acl share_name, signed_identifiers: identifiers - share.wont_be_nil - share.name.must_equal share_name - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(share).wont_be_nil + _(share.name).must_equal share_name + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission share, acl = subject.get_share_acl share_name - share.wont_be_nil - share.name.must_equal share_name - acl.length.must_equal identifiers.length - acl.first.id.must_equal identifiers.first.id - acl.first.access_policy.start.must_equal identifiers.first.access_policy.start - acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry - acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission + _(share).wont_be_nil + _(share.name).must_equal share_name + _(acl.length).must_equal identifiers.length + _(acl.first.id).must_equal identifiers.first.id + _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start + _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry + _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission end it "errors if the share does not exist" do diff --git a/test/integration/file/share_metadata_test.rb b/test/integration/file/share_metadata_test.rb index b568c0d7f9ccd15f1c1cb1c1af60aabf1ea1a502..7785f66bcd2f6d99ff23646cacc811cf1015be75 100644 --- a/test/integration/file/share_metadata_test.rb +++ b/test/integration/file/share_metadata_test.rb @@ -41,13 +41,13 @@ describe Azure::Storage::File::FileService do it "sets and gets custom metadata for the share" do result = subject.set_share_metadata share_name, metadata - result.must_be_nil + _(result).must_be_nil share = subject.get_share_metadata share_name - share.wont_be_nil - share.name.must_equal share_name + _(share).wont_be_nil + _(share.name).must_equal share_name metadata.each { |k, v| - share.metadata.must_include k.downcase - share.metadata[k.downcase].must_equal v + _(share.metadata).must_include k.downcase + _(share.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/share_properties_test.rb b/test/integration/file/share_properties_test.rb index 824c1e03a809534f4407589e82b8c465e9a2f814..49819b2017948a57973972708926836cb94df86a 100644 --- a/test/integration/file/share_properties_test.rb +++ b/test/integration/file/share_properties_test.rb @@ -36,14 +36,14 @@ describe Azure::Storage::File::FileService do properties = share.properties share = subject.get_share_properties share_name - share.wont_be_nil - share.name.must_equal share_name - share.properties[:etag].must_equal properties[:etag] - share.properties[:last_modified].must_equal properties[:last_modified] + _(share).wont_be_nil + _(share.name).must_equal share_name + _(share.properties[:etag]).must_equal properties[:etag] + _(share.properties[:last_modified]).must_equal properties[:last_modified] metadata.each { |k, v| - share.metadata.must_include k.downcase - share.metadata[k.downcase].must_equal v + _(share.metadata).must_include k.downcase + _(share.metadata[k.downcase]).must_equal v } end @@ -64,15 +64,15 @@ describe Azure::Storage::File::FileService do properties = share.properties share = subject.set_share_properties share_name, quota: share_quota - share.must_be_nil + _(share).must_be_nil share = subject.get_share_properties share_name - share.name.must_equal share_name - share.quota.must_equal share_quota + _(share.name).must_equal share_name + _(share.quota).must_equal share_quota metadata.each { |k, v| - share.metadata.must_include k.downcase - share.metadata[k.downcase].must_equal v + _(share.metadata).must_include k.downcase + _(share.metadata[k.downcase]).must_equal v } end diff --git a/test/integration/file/share_stats_test.rb b/test/integration/file/share_stats_test.rb index b352740d0ab1d02423485f7936db8076cf36db4a..348d28298a15fe7b4fdc5913120516c3ead65759 100644 --- a/test/integration/file/share_stats_test.rb +++ b/test/integration/file/share_stats_test.rb @@ -35,9 +35,9 @@ describe Azure::Storage::File::FileService do properties = share.properties share = subject.get_share_stats share_name - share.wont_be_nil - share.name.must_equal share_name - share.usage.must_equal 0 + _(share).wont_be_nil + _(share.name).must_equal share_name + _(share.usage).must_equal 0 end it "errors if the share does not exist" do diff --git a/test/integration/queue/clear_messages_test.rb b/test/integration/queue/clear_messages_test.rb index 2ecad78cc801e711f5f1d6e403cd279e46d660ce..8c4f81b25ba62d7d2b9562ec9006aaf7017dbe31 100644 --- a/test/integration/queue/clear_messages_test.rb +++ b/test/integration/queue/clear_messages_test.rb @@ -36,9 +36,9 @@ describe Azure::Storage::Queue::QueueService do it "clears the queue" do result = subject.clear_messages queue_name - result.must_be_nil + _(result).must_be_nil result = subject.peek_messages queue_name - result.must_be_empty + _(result).must_be_empty end it "errors on an non-existent queue" do diff --git a/test/integration/queue/create_message_test.rb b/test/integration/queue/create_message_test.rb index 916ca446521a4d56f6a1b784fb4c79fc18ea3cc7..d587f90c9832898f1e34776ae6cc42138982c2cb 100644 --- a/test/integration/queue/create_message_test.rb +++ b/test/integration/queue/create_message_test.rb @@ -34,18 +34,18 @@ describe Azure::Storage::Queue::QueueService do it "creates a message in the specified queue and returns nil on success" do result = subject.create_message(queue_name, message_text) - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_be_nil - result[0].pop_receipt.wont_be_nil - result[0].id.wont_be_nil + _(result.length).must_equal 1 + _(result[0].message_text).must_be_nil + _(result[0].pop_receipt).wont_be_nil + _(result[0].id).wont_be_nil result = subject.peek_messages queue_name - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_equal message_text + _(result.length).must_equal 1 + _(result[0].message_text).must_equal message_text end @@ -56,53 +56,53 @@ describe Azure::Storage::Queue::QueueService do it "the :visibility_timeout option causes the message to be invisible for a period of time" do result = subject.create_message(queue_name, message_text, visibility_timeout: visibility_timeout) - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_be_nil - result[0].pop_receipt.wont_be_nil - result[0].id.wont_be_nil + _(result.length).must_equal 1 + _(result[0].message_text).must_be_nil + _(result[0].pop_receipt).wont_be_nil + _(result[0].id).wont_be_nil result = subject.peek_messages queue_name - result.length.must_equal 0 + _(result.length).must_equal 0 sleep(visibility_timeout) result = subject.peek_messages queue_name - result.length.must_equal 1 + _(result.length).must_equal 1 result.wont_be_empty - result[0].message_text.must_equal message_text + _(result[0].message_text).must_equal message_text end it "the :message_ttl option modifies the expiration_date of the message" do result = subject.create_message(queue_name, message_text, message_ttl: message_ttl) - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_be_nil - result[0].pop_receipt.wont_be_nil - result[0].id.wont_be_nil + _(result.length).must_equal 1 + _(result[0].message_text).must_be_nil + _(result[0].pop_receipt).wont_be_nil + _(result[0].id).wont_be_nil result = subject.peek_messages queue_name - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty message = result[0] - message.message_text.must_equal message_text - Time.parse(message.expiration_time).to_i.must_equal Time.parse(message.insertion_time).to_i + message_ttl + _(message.message_text).must_equal message_text + _(Time.parse(message.expiration_time).to_i).must_equal Time.parse(message.insertion_time).to_i + message_ttl end it "the :encode option encodes with strict base64" do result = subject.create_message(queue_name, message_text, encode: encode) - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].message_text.must_be_nil - result[0].pop_receipt.wont_be_nil - result[0].id.wont_be_nil + _(result.length).must_equal 1 + _(result[0].message_text).must_be_nil + _(result[0].pop_receipt).wont_be_nil + _(result[0].id).wont_be_nil result = subject.peek_messages queue_name - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result[0].message_text.must_equal Base64.strict_encode64(message_text) + _(result[0].message_text).must_equal Base64.strict_encode64(message_text) end end diff --git a/test/integration/queue/create_queue_test.rb b/test/integration/queue/create_queue_test.rb index ffbb73c6edac34ab4ee01c753d9cfc4488962402..c98462b641a2d7f4f34dd3b2c3fcbabd6c0d73a0 100644 --- a/test/integration/queue/create_queue_test.rb +++ b/test/integration/queue/create_queue_test.rb @@ -39,18 +39,18 @@ describe Azure::Storage::Queue::QueueService do it "creates a queue with a valid name" do result = subject.create_queue queue_name - result.must_be_nil + _(result).must_be_nil end it "creates a queue with a valid name and metadata" do result = subject.create_queue queue_name, metadata: metadata - result.must_be_nil + _(result).must_be_nil message_count, queue_metadata = subject.get_queue_metadata queue_name metadata.each { |k, v| - queue_metadata.must_include k - queue_metadata[k].must_equal v + _(queue_metadata).must_include k + _(queue_metadata[k]).must_equal v } end diff --git a/test/integration/queue/delete_message_test.rb b/test/integration/queue/delete_message_test.rb index 840229bfb79aab8c52ca5e110a29313f630e0ef5..8bd4b7a533cfa7fc10c2a1a6963daeda37548559 100644 --- a/test/integration/queue/delete_message_test.rb +++ b/test/integration/queue/delete_message_test.rb @@ -36,14 +36,14 @@ describe Azure::Storage::Queue::QueueService do it "deletes a message" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first result = subject.delete_message queue_name, message.id, message.pop_receipt - result.must_be_nil + _(result).must_be_nil result = subject.peek_messages queue_name - result.must_be_empty + _(result).must_be_empty end it "errors on an non-existent queue" do @@ -54,7 +54,7 @@ describe Azure::Storage::Queue::QueueService do it "errors on an non-existent message id" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first assert_raises(Azure::Core::Http::HTTPError) do @@ -64,7 +64,7 @@ describe Azure::Storage::Queue::QueueService do it "errors on an non-existent pop_receipt" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first assert_raises(Azure::Core::Http::HTTPError) do diff --git a/test/integration/queue/delete_queue_test.rb b/test/integration/queue/delete_queue_test.rb index f651193dbf8df28bbf881940c800bb031f3b0e83..049cb1dad73d9f727db93a1309606c9fb012f9a0 100644 --- a/test/integration/queue/delete_queue_test.rb +++ b/test/integration/queue/delete_queue_test.rb @@ -33,7 +33,7 @@ describe Azure::Storage::Queue::QueueService do it "deletes a queue and returns nil on success" do result = subject.delete_queue(queue_name) - result.must_be_nil + _(result).must_be_nil result = subject.list_queues result.each { |q| q.name.wont_equal queue_name } end diff --git a/test/integration/queue/informative_errors_test.rb b/test/integration/queue/informative_errors_test.rb index 0a8981ef87b52398f9fc2ece459f31b757398b83..ced4bf0f10a1ee801cd579dfb86d9c8f94ba130a 100644 --- a/test/integration/queue/informative_errors_test.rb +++ b/test/integration/queue/informative_errors_test.rb @@ -37,9 +37,9 @@ describe Azure::Storage::Queue::QueueService do subject.get_queue_metadata queue_name flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 404 - error.type.must_equal "QueueNotFound" - error.description.start_with?("The specified queue does not exist.").must_equal true + _(error.status_code).must_equal 404 + _(error.type).must_equal "QueueNotFound" + _(error.description.start_with?("The specified queue does not exist.")).must_equal true end end end diff --git a/test/integration/queue/list_messages_encoded_test.rb b/test/integration/queue/list_messages_encoded_test.rb index 3fbb5cc6bcc775fa666228d454bd2df6a7a56252..6070e7d4eb6dde0f5361c72feae82a2c95a95071 100644 --- a/test/integration/queue/list_messages_encoded_test.rb +++ b/test/integration/queue/list_messages_encoded_test.rb @@ -37,15 +37,15 @@ describe Azure::Storage::Queue::QueueService do it "returns a message from the queue, marking it as invisible" do result = subject.list_messages queue_name, 3, decode: true - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message = result[0] - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text # queue should be empty result = subject.list_messages queue_name, 1, decode: true - result.must_be_empty + _(result).must_be_empty end it "returns multiple messages if passed the optional parameter" do @@ -53,35 +53,35 @@ describe Azure::Storage::Queue::QueueService do subject.create_message queue_name, msg_text2, encode: true result = subject.list_messages queue_name, 3, number_of_messages: 2, decode: true - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 2 - result[0].message_text.must_equal message_text - result[1].message_text.must_equal msg_text2 + _(result.length).must_equal 2 + _(result[0].message_text).must_equal message_text + _(result[1].message_text).must_equal msg_text2 result[0].id.wont_equal result[1].id end it "the visibility_timeout parameter sets the message invisible for the period of time pending delete/update" do result = subject.list_messages queue_name, 3, decode: true - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message = result[0] - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text # queue should be empty result = subject.list_messages queue_name, 1, decode: true - result.must_be_empty + _(result).must_be_empty sleep(3) # same message is back at the top of the queue after timeout period result = subject.list_messages queue_name, 3, decode: true - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message2 = result[0] - message2.id.must_equal message.id + _(message2.id).must_equal message.id end end end diff --git a/test/integration/queue/list_messages_test.rb b/test/integration/queue/list_messages_test.rb index 97de4864b294a84fbd214d2499f5ca40fe36f2e8..d7ce4cc0a581f835a78c3e9e67159d24e4bffc01 100644 --- a/test/integration/queue/list_messages_test.rb +++ b/test/integration/queue/list_messages_test.rb @@ -37,15 +37,15 @@ describe Azure::Storage::Queue::QueueService do it "returns a message from the queue, marking it as invisible" do result = subject.list_messages queue_name, 3 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message = result[0] - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text # queue should be empty result = subject.list_messages queue_name, 1 - result.must_be_empty + _(result).must_be_empty end it "returns multiple messages if passed the optional parameter" do @@ -53,35 +53,35 @@ describe Azure::Storage::Queue::QueueService do subject.create_message queue_name, msg_text2 result = subject.list_messages queue_name, 3, number_of_messages: 2 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 2 - result[0].message_text.must_equal message_text - result[1].message_text.must_equal msg_text2 + _(result.length).must_equal 2 + _(result[0].message_text).must_equal message_text + _(result[1].message_text).must_equal msg_text2 result[0].id.wont_equal result[1].id end it "the visibility_timeout parameter sets the message invisible for the period of time pending delete/update" do result = subject.list_messages queue_name, 3 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message = result[0] - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text # queue should be empty result = subject.list_messages queue_name, 1 - result.must_be_empty + _(result).must_be_empty sleep(3) # same message is back at the top of the queue after timeout period result = subject.list_messages queue_name, 3 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message2 = result[0] - message2.id.must_equal message.id + _(message2.id).must_equal message.id end end end diff --git a/test/integration/queue/list_queues_test.rb b/test/integration/queue/list_queues_test.rb index 7e1a1899ee26f190f476937162510ee495254617..9912c689d4a294b614ef29ba0b5724c3505ccfac 100644 --- a/test/integration/queue/list_queues_test.rb +++ b/test/integration/queue/list_queues_test.rb @@ -39,13 +39,13 @@ describe Azure::Storage::Queue::QueueService do begin result = subject.list_queues(marker: next_marker) result.each { |q| - q.name.wont_be_nil + _(q.name).wont_be_nil expected_queues += 1 if queue_names.include? q.name } next_marker = result.continuation_token end while next_marker != "" - expected_queues.must_equal queue_names.length + _(expected_queues).must_equal queue_names.length end end end diff --git a/test/integration/queue/peek_messages_test.rb b/test/integration/queue/peek_messages_test.rb index 6726847c6d6f82b8151587e18fc1516ffdde3d15..cf04a41b82fc059527fb5f05e1d20b843d03ea15 100644 --- a/test/integration/queue/peek_messages_test.rb +++ b/test/integration/queue/peek_messages_test.rb @@ -38,18 +38,18 @@ describe Azure::Storage::Queue::QueueService do it "returns a message from the queue without marking it as invisible" do result = subject.peek_messages queue_name - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 + _(result.length).must_equal 1 message = result[0] - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text # the same message is returned on another call, because it's still at the top of the queue result = subject.peek_messages queue_name - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 1 - result[0].id.must_equal message.id + _(result.length).must_equal 1 + _(result[0].id).must_equal message.id end it "returns multiple messages if passed the optional parameter" do @@ -57,11 +57,11 @@ describe Azure::Storage::Queue::QueueService do subject.create_message queue_name, msg_text2 result = subject.peek_messages queue_name, number_of_messages: 2 - result.wont_be_nil + _(result).wont_be_nil result.wont_be_empty - result.length.must_equal 2 - result[0].message_text.must_equal message_text - result[1].message_text.must_equal msg_text2 + _(result.length).must_equal 2 + _(result[0].message_text).must_equal message_text + _(result[1].message_text).must_equal msg_text2 result[0].id.wont_equal result[1].id end end diff --git a/test/integration/queue/queue_gb18030_test.rb b/test/integration/queue/queue_gb18030_test.rb index bb4175cc925e34b5aecb0aaeaf6745023c6273b7..dc5812d5cd765418fa5d1b0c12186039fa38169f 100644 --- a/test/integration/queue/queue_gb18030_test.rb +++ b/test/integration/queue/queue_gb18030_test.rb @@ -68,7 +68,7 @@ describe "Queue GB-18030" do subject.set_queue_metadata queue_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -80,7 +80,7 @@ describe "Queue GB-18030" do subject.set_queue_metadata queue_name, metadata flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 400 + _(error.status_code).must_equal 400 end } end @@ -93,7 +93,7 @@ describe "Queue GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -106,7 +106,7 @@ describe "Queue GB-18030" do flunk "No exception" rescue Azure::Core::Http::HTTPError => error # TODO: Error should really be 400 - error.status_code.must_equal 403 + _(error.status_code).must_equal 403 end } end @@ -118,7 +118,7 @@ describe "Queue GB-18030" do messages = subject.list_messages queue_name, 500 message = messages.first returned_content = message.message_text - returned_content.must_equal content + _(returned_content).must_equal content subject.delete_message queue_name, message.id, message.pop_receipt } end @@ -132,7 +132,7 @@ describe "Queue GB-18030" do messages = subject.list_messages queue_name, 500 message = messages.first returned_content = message.message_text - returned_content.encode("UTF-8").must_equal content.encode("UTF-8") + _(returned_content.encode("UTF-8")).must_equal content.encode("UTF-8") subject.delete_message queue_name, message.id, message.pop_receipt } end diff --git a/test/integration/queue/queue_metadata_test.rb b/test/integration/queue/queue_metadata_test.rb index 675265e466584930c63f9f5ccc22de233d8147db..22302b6009bf73f205998319ffbd8c06b0bc2e77 100644 --- a/test/integration/queue/queue_metadata_test.rb +++ b/test/integration/queue/queue_metadata_test.rb @@ -35,14 +35,14 @@ describe Azure::Storage::Queue::QueueService do it "can set and retrieve queue metadata" do result = subject.set_queue_metadata queue_name, "CustomMetadataProperty" => "Custom Metadata Value" - result.must_be_nil + _(result).must_be_nil message_count, metadata = subject.get_queue_metadata queue_name - message_count.must_equal 1 + _(message_count).must_equal 1 # note: case insensitive! even though it was sent in mixed case, it will be returned in downcase - metadata.must_include "custommetadataproperty" - metadata["custommetadataproperty"].must_equal "Custom Metadata Value" + _(metadata).must_include "custommetadataproperty" + _(metadata["custommetadataproperty"]).must_equal "Custom Metadata Value" end end end diff --git a/test/integration/queue/queue_service_stats_test.rb b/test/integration/queue/queue_service_stats_test.rb index d5453fe0840274ad5b49bd3485f1bc4f97a6644c..7f5e81c51aa508aba59ed49f430aee568f57dc48 100644 --- a/test/integration/queue/queue_service_stats_test.rb +++ b/test/integration/queue/queue_service_stats_test.rb @@ -30,9 +30,9 @@ describe Azure::Storage::Queue::QueueService do describe "#get_service_stats" do it "gets service stats" do stats = subject.get_service_stats - stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication - stats.geo_replication.status.must_equal "live" - stats.geo_replication.last_sync_time.must_be_kind_of Time + _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication + _(stats.geo_replication.status).must_equal "live" + _(stats.geo_replication.last_sync_time).must_be_kind_of Time end end end diff --git a/test/integration/queue/update_message_test.rb b/test/integration/queue/update_message_test.rb index 4882890f6653415aa819dacd72573f1ce50bee54..1147c79fa1c155eb15a0baca3a31093ae3223955 100644 --- a/test/integration/queue/update_message_test.rb +++ b/test/integration/queue/update_message_test.rb @@ -39,9 +39,9 @@ describe Azure::Storage::Queue::QueueService do it "updates a message" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first - message.message_text.must_equal message_text + _(message.message_text).must_equal message_text pop_receipt, time_next_visible = subject.update_message queue_name, message.id, message.pop_receipt, new_message_text, 0 @@ -49,8 +49,8 @@ describe Azure::Storage::Queue::QueueService do result.wont_be_empty message2 = result[0] - message2.id.must_equal message.id - message2.message_text.must_equal new_message_text + _(message2.id).must_equal message.id + _(message2.message_text).must_equal new_message_text end it "errors on an non-existent queue" do @@ -61,7 +61,7 @@ describe Azure::Storage::Queue::QueueService do it "errors on an non-existent message id" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first assert_raises(Azure::Core::Http::HTTPError) do @@ -71,7 +71,7 @@ describe Azure::Storage::Queue::QueueService do it "errors on an non-existent pop_receipt" do messages = subject.list_messages queue_name, 500 - messages.length.must_equal 1 + _(messages.length).must_equal 1 message = messages.first assert_raises(Azure::Core::Http::HTTPError) do diff --git a/test/integration/table/create_table_test.rb b/test/integration/table/create_table_test.rb index c3e6b0c132781e170324333d268af33c33ff990f..2c2f22217c58c724102b86cdacb57fd462ab5efb 100644 --- a/test/integration/table/create_table_test.rb +++ b/test/integration/table/create_table_test.rb @@ -37,7 +37,7 @@ describe Azure::Storage::Table::TableService do it "creates a table with a valid name" do result = subject.create_table(table_name) - result.must_be_nil + _(result).must_be_nil end it "errors on an invalid table name" do diff --git a/test/integration/table/delete_entity_batch_test.rb b/test/integration/table/delete_entity_batch_test.rb index 896922938594b6a70591aaad35f940bf22a18c5e..fa8329491ac9efcdd397dca6c8642e62d8a01ab2 100644 --- a/test/integration/table/delete_entity_batch_test.rb +++ b/test/integration/table/delete_entity_batch_test.rb @@ -50,7 +50,7 @@ describe Azure::Storage::Table::TableService do batch = Azure::Storage::Table::Batch.new table_name, entity_properties["PartitionKey"] batch.delete entity_properties["RowKey"] results = subject.execute_batch batch - results[0].must_be_nil + _(results[0]).must_be_nil # query entity to make sure it was deleted assert_raises(Azure::Core::Http::HTTPError, "ResourceNotFound (404): The specified resource does not exist.") do @@ -82,9 +82,9 @@ describe Azure::Storage::Table::TableService do results = subject.execute_batch batch - results[0].must_be_nil - results[1].must_be_nil - results[2].must_be_nil + _(results[0]).must_be_nil + _(results[1]).must_be_nil + _(results[2]).must_be_nil end it "errors on an invalid table name" do diff --git a/test/integration/table/delete_entity_test.rb b/test/integration/table/delete_entity_test.rb index ac23e33973344b2fb16058d077b394145a60ac6e..695d78bfc3006310da6d8bc28c9f40edc14df813 100644 --- a/test/integration/table/delete_entity_test.rb +++ b/test/integration/table/delete_entity_test.rb @@ -48,7 +48,7 @@ describe Azure::Storage::Table::TableService do it "deletes an entity" do result = subject.delete_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_nil + _(result).must_be_nil # query entity to make sure it was deleted assert_raises(Azure::Core::Http::HTTPError, "ResourceNotFound (404): The specified resource does not exist.") do @@ -62,23 +62,23 @@ describe Azure::Storage::Table::TableService do entity["RowKey"] = "key with spaces" subject.insert_entity table_name, entity result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_nil + _(result).must_be_nil entity["RowKey"] = "key'with'quotes" subject.insert_entity table_name, entity result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_nil + _(result).must_be_nil # Uncomment when issue 145 (Cannot use GB-18030 characters in strings) is fixed #entity["RowKey"] = "keyWithUnicode" + 0xE.chr + 0x8B.chr + 0xA4.chr #subject.insert_entity table_name, entity #result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"] - #result.must_be_nil + #_(result).must_be_nil entity["RowKey"] = "Qbert_Says=.!@%^&" subject.insert_entity table_name, entity result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_nil + _(result).must_be_nil end it "errors on an invalid table name" do diff --git a/test/integration/table/delete_table_test.rb b/test/integration/table/delete_table_test.rb index 67e58235ac0dac5b8845679cc82b68f37ec8fb19..2a68bb4ad64836a2f79c8ef32a17ee7df6db71db 100644 --- a/test/integration/table/delete_table_test.rb +++ b/test/integration/table/delete_table_test.rb @@ -33,7 +33,7 @@ describe Azure::Storage::Table::TableService do it "deletes a table and returns nil on success" do result = subject.delete_table(table_name) - result.must_be_nil + _(result).must_be_nil tables = subject.query_tables tables.wont_include table_name diff --git a/test/integration/table/get_entity_batch_test.rb b/test/integration/table/get_entity_batch_test.rb index f85c7e464408039debe02d8f8641c67b1bda5616..236f73d18f9c20a6a67ce75c6ff841105e79812a 100644 --- a/test/integration/table/get_entity_batch_test.rb +++ b/test/integration/table/get_entity_batch_test.rb @@ -61,12 +61,12 @@ describe Azure::Storage::Table::TableService do batch = Azure::Storage::Table::Batch.new table_name, entity_properties["PartitionKey"] batch.get entity_properties["RowKey"] results = subject.execute_batch batch - results[0].must_be_kind_of Azure::Storage::Table::Entity + _(results[0]).must_be_kind_of Azure::Storage::Table::Entity entity_properties.each { |k, v| if entity_properties[k].class == Time - floor_to(results[0].properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6) + _(floor_to(results[0].properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6) else - results[0].properties[k].must_equal entity_properties[k] + _(results[0].properties[k]).must_equal entity_properties[k] end } end diff --git a/test/integration/table/get_table_test.rb b/test/integration/table/get_table_test.rb index b2d735c1f1d5ecc570793ec9e9972824c138f430..a19748ac5035d918485f825040fcbbbef392c23f 100644 --- a/test/integration/table/get_table_test.rb +++ b/test/integration/table/get_table_test.rb @@ -33,8 +33,8 @@ describe Azure::Storage::Table::TableService do it "gets the last updated time of a valid table" do result = subject.get_table table_name - result.must_be_kind_of Hash - result["TableName"].must_equal table_name + _(result).must_be_kind_of Hash + _(result["TableName"]).must_equal table_name end it "errors on an invalid table" do diff --git a/test/integration/table/informative_errors_test.rb b/test/integration/table/informative_errors_test.rb index af8208f5fcb9bf1817f60bd82aa0d4b6484cced2..931f2e03a1635abc12b4dcd3df096c5dafbe3ce1 100644 --- a/test/integration/table/informative_errors_test.rb +++ b/test/integration/table/informative_errors_test.rb @@ -38,9 +38,9 @@ describe Azure::Storage::Table::TableService do subject.create_table(table_name) flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 409 - error.type.must_equal "TableAlreadyExists" - error.description.include?("The table specified already exists.").must_equal true + _(error.status_code).must_equal 409 + _(error.type).must_equal "TableAlreadyExists" + _(error.description.include?("The table specified already exists.")).must_equal true end end end diff --git a/test/integration/table/insert_entity_batch_test.rb b/test/integration/table/insert_entity_batch_test.rb index ae71f018bcca59f4e17851de92ddb96109e4abb6..20a64682a13c1d3f0310dbde809cfd7346f92dd6 100644 --- a/test/integration/table/insert_entity_batch_test.rb +++ b/test/integration/table/insert_entity_batch_test.rb @@ -61,12 +61,12 @@ describe Azure::Storage::Table::TableService do batch.insert entity_properties["RowKey"], entity_properties results = subject.execute_batch batch - results[0].must_be_kind_of Azure::Storage::Table::Entity + _(results[0]).must_be_kind_of Azure::Storage::Table::Entity entity_properties.each { |k, v| if entity_properties[k].class == Time - floor_to(results[0].properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6) + _(floor_to(results[0].properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6) else - results[0].properties[k].must_equal entity_properties[k] + _(results[0].properties[k]).must_equal entity_properties[k] end } end diff --git a/test/integration/table/insert_entity_test.rb b/test/integration/table/insert_entity_test.rb index 68c47f4152f07b6261ed9c95cf94c2005fc39ccb..336be1af604bd7c2c6a499d1601a157792a264e1 100644 --- a/test/integration/table/insert_entity_test.rb +++ b/test/integration/table/insert_entity_test.rb @@ -57,12 +57,12 @@ describe Azure::Storage::Table::TableService do after { TableNameHelper.clean } it "creates an entity" do result = subject.insert_entity table_name, entity_properties - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity entity_properties.each { |k, v| if entity_properties[k].class == Time - floor_to(result.properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6) + _(floor_to(result.properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6) else - result.properties[k].must_equal entity_properties[k] + _(result.properties[k]).must_equal entity_properties[k] end } end diff --git a/test/integration/table/insert_or_merge_entity_batch_test.rb b/test/integration/table/insert_or_merge_entity_batch_test.rb index 740b805a525f58c3b6e583e09477432946aa0ab8..d0043095b7f08dc8675c948f6bd994b67d4ed503 100644 --- a/test/integration/table/insert_or_merge_entity_batch_test.rb +++ b/test/integration/table/insert_or_merge_entity_batch_test.rb @@ -64,14 +64,14 @@ describe Azure::Storage::Table::TableService do result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.etag.wont_be_nil + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.etag).wont_be_nil entity.each { |k, v| unless entity[k].class == Time - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] else - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i end } end @@ -106,23 +106,23 @@ describe Azure::Storage::Table::TableService do result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.etag.must_be_kind_of String + _(result.etag).must_be_kind_of String result.etag.wont_equal existing_etag - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # retained all existing props entity.each { |k, v| if entity[k].class == Time - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i else - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] end } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" - result.properties["NewNilProperty"].must_equal nil + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" + _(result.properties["NewNilProperty"]).must_equal nil end it "errors on an invalid table name" do diff --git a/test/integration/table/insert_or_merge_entity_test.rb b/test/integration/table/insert_or_merge_entity_test.rb index 9564938b9a7a69cca6a926051458a1d58c578784..7dda88ded0d33fe955a01c967b89ac8742a03cdc 100644 --- a/test/integration/table/insert_or_merge_entity_test.rb +++ b/test/integration/table/insert_or_merge_entity_test.rb @@ -59,18 +59,18 @@ describe Azure::Storage::Table::TableService do assert does_not_exist etag = subject.insert_or_merge_entity table_name, entity - etag.must_be_kind_of String + _(etag).must_be_kind_of String result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.etag.must_equal etag + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.etag).must_equal etag entity.each { |k, v| unless entity[k].class == Time - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] else - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i end } end @@ -98,25 +98,25 @@ describe Azure::Storage::Table::TableService do "NewCustomProperty" => "NewCustomValue", "NewNilProperty" => nil - etag.must_be_kind_of String + _(etag).must_be_kind_of String etag.wont_equal existing_etag result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # retained all existing props entity.each { |k, v| if entity[k].class == Time - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i else - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] end } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" - result.properties["NewNilProperty"].must_equal nil + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" + _(result.properties["NewNilProperty"]).must_equal nil end it "errors on an invalid table name" do diff --git a/test/integration/table/insert_or_replace_entity_batch_test.rb b/test/integration/table/insert_or_replace_entity_batch_test.rb index 62fdaffbd74a8016b2647aee91cdf125e37f3a1c..4664d5e238c2b579163244d4303a446ede51a40b 100644 --- a/test/integration/table/insert_or_replace_entity_batch_test.rb +++ b/test/integration/table/insert_or_replace_entity_batch_test.rb @@ -62,18 +62,18 @@ describe Azure::Storage::Table::TableService do batch.insert_or_replace entity["RowKey"], entity etags = subject.execute_batch batch - etags[0].must_be_kind_of String + _(etags[0]).must_be_kind_of String result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.etag.must_equal etags[0] + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.etag).must_equal etags[0] entity.each { |k, v| unless entity[k].class == Time - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] else - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i end } end @@ -102,12 +102,12 @@ describe Azure::Storage::Table::TableService do "NewCustomProperty" => "NewCustomValue" etags = subject.execute_batch batch - etags[0].must_be_kind_of String + _(etags[0]).must_be_kind_of String etags[0].wont_equal existing_etag result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity.each { |k, v| @@ -115,7 +115,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "errors on an invalid table name" do diff --git a/test/integration/table/insert_or_replace_entity_test.rb b/test/integration/table/insert_or_replace_entity_test.rb index 0271c468d3d1ab1de5bd0e801b02f3967a4b67ec..4c8dacc99ac873c192f01110a46149a5373861ca 100644 --- a/test/integration/table/insert_or_replace_entity_test.rb +++ b/test/integration/table/insert_or_replace_entity_test.rb @@ -59,18 +59,18 @@ describe Azure::Storage::Table::TableService do assert does_not_exist etag = subject.insert_or_replace_entity table_name, entity - etag.must_be_kind_of String + _(etag).must_be_kind_of String result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.etag.must_equal etag + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.etag).must_equal etag entity.each { |k, v| unless entity[k].class == Time - result.properties[k].must_equal entity[k] + _(result.properties[k]).must_equal entity[k] else - result.properties[k].to_i.must_equal entity[k].to_i + _(result.properties[k].to_i).must_equal entity[k].to_i end } end @@ -97,12 +97,12 @@ describe Azure::Storage::Table::TableService do "RowKey" => entity["RowKey"], "NewCustomProperty" => "NewCustomValue" - etag.must_be_kind_of String + _(etag).must_be_kind_of String etag.wont_equal existing_etag result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity.each { |k, v| @@ -110,7 +110,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "errors on an invalid table name" do diff --git a/test/integration/table/merge_entity_batch_test.rb b/test/integration/table/merge_entity_batch_test.rb index f4a30a215db14fcca4c0a4940cfd7af8e3b5cf09..a37123ad6030ea67bbcca74d8134528aa0027d55 100644 --- a/test/integration/table/merge_entity_batch_test.rb +++ b/test/integration/table/merge_entity_batch_test.rb @@ -66,26 +66,26 @@ describe Azure::Storage::Table::TableService do "NewCustomProperty" => "NewCustomValue" etags = subject.execute_batch batch - etags[0].must_be_kind_of String + _(etags[0]).must_be_kind_of String etags[0].wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.properties["PartitionKey"].must_equal entity_properties["PartitionKey"] - result.properties["RowKey"].must_equal entity_properties["RowKey"] + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.properties["PartitionKey"]).must_equal entity_properties["PartitionKey"] + _(result.properties["RowKey"]).must_equal entity_properties["RowKey"] # retained all existing props entity_properties.each { |k, v| unless entity_properties[k].class == Time - result.properties[k].must_equal entity_properties[k] + _(result.properties[k]).must_equal entity_properties[k] else - result.properties[k].to_i.must_equal entity_properties[k].to_i + _(result.properties[k].to_i).must_equal entity_properties[k].to_i end } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "errors on a non-existing row key" do diff --git a/test/integration/table/merge_entity_test.rb b/test/integration/table/merge_entity_test.rb index 4cb72d2520886b1fab042823f770d62c1f8db9ba..d9f4fb4e1e050f783fe696d7ab2aebf98a0ecd60 100644 --- a/test/integration/table/merge_entity_test.rb +++ b/test/integration/table/merge_entity_test.rb @@ -63,26 +63,26 @@ describe Azure::Storage::Table::TableService do etag = subject.merge_entity table_name, PartitionKey: entity_properties["PartitionKey"], RowKey: entity_properties["RowKey"], NewCustomProperty: "NewCustomValue" - etag.must_be_kind_of String + _(etag).must_be_kind_of String etag.wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity - result.properties["PartitionKey"].must_equal entity_properties["PartitionKey"] - result.properties["RowKey"].must_equal entity_properties["RowKey"] + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.properties["PartitionKey"]).must_equal entity_properties["PartitionKey"] + _(result.properties["RowKey"]).must_equal entity_properties["RowKey"] # retained all existing props entity_properties.each { |k, v| unless entity_properties[k].class == Time - result.properties[k].must_equal entity_properties[k] + _(result.properties[k]).must_equal entity_properties[k] else - result.properties[k].to_i.must_equal entity_properties[k].to_i + _(result.properties[k].to_i).must_equal entity_properties[k].to_i end } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "errors on a non-existing row key" do diff --git a/test/integration/table/query_entities_test.rb b/test/integration/table/query_entities_test.rb index 6fa7d699720fe6014c30e564ae20915f52f303df..a41742a5737a0ecdb1e3f167d3f4c904568e9094 100644 --- a/test/integration/table/query_entities_test.rb +++ b/test/integration/table/query_entities_test.rb @@ -66,16 +66,16 @@ describe Azure::Storage::Table::TableService do it "Queries a table for list of entities" do result = subject.query_entities table_name - result.must_be_kind_of Array - result.length.must_equal ((partitions.length + 1) * entities_per_partition) + _(result).must_be_kind_of Array + _(result.length).must_equal ((partitions.length + 1) * entities_per_partition) result.each { |e| - entities[e.properties["PartitionKey"]].must_include e.properties["RowKey"] + _(entities[e.properties["PartitionKey"]]).must_include e.properties["RowKey"] entity_properties.each { |k, v| unless v.class == Time - e.properties[k].must_equal v + _(e.properties[k]).must_equal v else - e.properties[k].to_i.must_equal v.to_i + _(e.properties[k].to_i).must_equal v.to_i end } } @@ -86,16 +86,16 @@ describe Azure::Storage::Table::TableService do row_key = entities[partition][0] result = subject.query_entities table_name, partition_key: partition, row_key: row_key - result.must_be_kind_of Array - result.length.must_equal 1 + _(result).must_be_kind_of Array + _(result.length).must_equal 1 result.each { |e| - e.properties["RowKey"].must_equal row_key + _(e.properties["RowKey"]).must_equal row_key entity_properties.each { |k, v| unless v.class == Time - e.properties[k].must_equal v + _(e.properties[k]).must_equal v else - e.properties[k].to_i.must_equal v.to_i + _(e.properties[k].to_i).must_equal v.to_i end } } @@ -105,14 +105,14 @@ describe Azure::Storage::Table::TableService do projection = ["CustomIntegerProperty", "ThisPropertyDoesNotExist"] puts "#########################################" result = subject.query_entities table_name, select: projection - result.must_be_kind_of Array - result.length.must_equal ((partitions.length + 1) * entities_per_partition) + _(result).must_be_kind_of Array + _(result.length).must_equal ((partitions.length + 1) * entities_per_partition) result.each { |e| - e.properties.length.must_equal projection.length - e.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"] - e.properties.must_include "ThisPropertyDoesNotExist" - e.properties["ThisPropertyDoesNotExist"].must_equal "" + _(e.properties.length).must_equal projection.length + _(e.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"] + _(e.properties).must_include "ThisPropertyDoesNotExist" + _(e.properties["ThisPropertyDoesNotExist"]).must_equal "" } end @@ -124,43 +124,43 @@ describe Azure::Storage::Table::TableService do filter = "CustomIntegerProperty gt #{entity_properties["CustomIntegerProperty"]} and CustomBooleanProperty eq false" result = subject.query_entities table_name, filter: filter - result.must_be_kind_of Array - result.length.must_equal 1 - result.first.properties["PartitionKey"].must_equal "filter-test-partition" + _(result).must_be_kind_of Array + _(result.length).must_equal 1 + _(result.first.properties["PartitionKey"]).must_equal "filter-test-partition" filter = "CustomIntegerProperty gt #{entity_properties["CustomIntegerProperty"]} and CustomBooleanProperty eq true" result = subject.query_entities table_name, filter: filter - result.must_be_kind_of Array - result.length.must_equal 0 + _(result).must_be_kind_of Array + _(result.length).must_equal 0 end it "can limit the result set using the top parameter" do result = subject.query_entities table_name, top: 3 - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil end it "can page results using the top parameter and continuation_token" do result = subject.query_entities table_name, top: 3 - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil result2 = subject.query_entities table_name, top: 3, continuation_token: result.continuation_token - result2.must_be_kind_of Array - result2.length.must_equal 3 - result2.continuation_token.wont_be_nil + _(result2).must_be_kind_of Array + _(result2.length).must_equal 3 + _(result2.continuation_token).wont_be_nil result3 = subject.query_entities table_name, top: 3, continuation_token: result2.continuation_token - result3.must_be_kind_of Array - result3.length.must_equal 3 - result3.continuation_token.wont_be_nil + _(result3).must_be_kind_of Array + _(result3.length).must_equal 3 + _(result3.continuation_token).wont_be_nil result4 = subject.query_entities table_name, top: 3, continuation_token: result3.continuation_token - result4.must_be_kind_of Array - result4.length.must_equal 3 - result4.continuation_token.must_be_nil + _(result4).must_be_kind_of Array + _(result4.length).must_equal 3 + _(result4.continuation_token).must_be_nil end it "can combine projection, filtering, and paging in the same query" do @@ -172,28 +172,28 @@ describe Azure::Storage::Table::TableService do filter = "CustomIntegerProperty eq #{entity_properties["CustomIntegerProperty"]}" projection = ["PartitionKey", "CustomIntegerProperty"] result = subject.query_entities table_name, select: projection, filter: filter, top: 3 - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil - result.first.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"] - result.first.properties["PartitionKey"].wont_be_nil - result.first.properties.length.must_equal 2 + _(result.first.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"] + _(result.first.properties["PartitionKey"]).wont_be_nil + _(result.first.properties.length).must_equal 2 result2 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result.continuation_token - result2.must_be_kind_of Array - result2.length.must_equal 3 - result2.continuation_token.wont_be_nil + _(result2).must_be_kind_of Array + _(result2.length).must_equal 3 + _(result2.continuation_token).wont_be_nil result3 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result2.continuation_token - result3.must_be_kind_of Array - result3.length.must_equal 3 - result3.continuation_token.wont_be_nil + _(result3).must_be_kind_of Array + _(result3.length).must_equal 3 + _(result3.continuation_token).wont_be_nil result4 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result3.continuation_token - result4.must_be_kind_of Array - result4.length.must_equal 3 - result4.continuation_token.must_be_nil + _(result4).must_be_kind_of Array + _(result4.length).must_equal 3 + _(result4.continuation_token).must_be_nil end end diff --git a/test/integration/table/query_tables_test.rb b/test/integration/table/query_tables_test.rb index f33bec4e968f05aa95e9cbcdd623f3ace0005271..f28b703f782e78df9baf3350e7f4fde7cdd14c7c 100644 --- a/test/integration/table/query_tables_test.rb +++ b/test/integration/table/query_tables_test.rb @@ -39,13 +39,13 @@ describe Azure::Storage::Table::TableService do result.continuation_token = nil result.concat(subject.query_tables(next_table_token: token)) end - result.must_be_kind_of Array + _(result).must_be_kind_of Array tables.each { |t| table = result.find { |c| c["TableName"] == t } - table.wont_be_nil + _(table).wont_be_nil } end end diff --git a/test/integration/table/query_test.rb b/test/integration/table/query_test.rb index 78a37a301b8921cec096485ccf8a8d302f53b93f..8d8bf7d7263f3dcdc5f19a75726ff8e0681ac119 100644 --- a/test/integration/table/query_test.rb +++ b/test/integration/table/query_test.rb @@ -74,16 +74,16 @@ describe Azure::Storage::Table::TableService do q = Azure::Storage::Table::Query.new.from table_name result = q.execute - result.must_be_kind_of Array - result.length.must_equal ((partitions.length + 1) * entities_per_partition) + _(result).must_be_kind_of Array + _(result.length).must_equal ((partitions.length + 1) * entities_per_partition) result.each { |e| - entities[e.properties["PartitionKey"]].must_include e.properties["RowKey"] + _(entities[e.properties["PartitionKey"]]).must_include e.properties["RowKey"] entity_properties.each { |k, v| unless v.class == Time - e.properties[k].must_equal v + _(e.properties[k]).must_equal v else - e.properties[k].to_i.must_equal v.to_i + _(e.properties[k].to_i).must_equal v.to_i end } } @@ -99,16 +99,16 @@ describe Azure::Storage::Table::TableService do .row(row_key) result = q.execute - result.must_be_kind_of Array - result.length.must_equal 1 + _(result).must_be_kind_of Array + _(result.length).must_equal 1 result.each { |e| - e.properties["RowKey"].must_equal row_key + _(e.properties["RowKey"]).must_equal row_key entity_properties.each { |k, v| unless v.class == Time - e.properties[k].must_equal v + _(e.properties[k]).must_equal v else - e.properties[k].to_i.must_equal v.to_i + _(e.properties[k].to_i).must_equal v.to_i end } } @@ -123,14 +123,14 @@ describe Azure::Storage::Table::TableService do .select(projection[1]) result = q.execute - result.must_be_kind_of Array - result.length.must_equal ((partitions.length + 1) * entities_per_partition) + _(result).must_be_kind_of Array + _(result.length).must_equal ((partitions.length + 1) * entities_per_partition) result.each { |e| - e.properties.length.must_equal projection.length - e.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"] - e.properties.must_include "ThisPropertyDoesNotExist" - e.properties["ThisPropertyDoesNotExist"].must_equal "" + _(e.properties.length).must_equal projection.length + _(e.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"] + _(e.properties).must_include "ThisPropertyDoesNotExist" + _(e.properties["ThisPropertyDoesNotExist"]).must_equal "" } end @@ -146,17 +146,17 @@ describe Azure::Storage::Table::TableService do .where("CustomBooleanProperty eq false") result = q.execute - result.must_be_kind_of Array - result.length.must_equal 1 - result.first.properties["PartitionKey"].must_equal "filter-test-partition" + _(result).must_be_kind_of Array + _(result.length).must_equal 1 + _(result.first.properties["PartitionKey"]).must_equal "filter-test-partition" q = Azure::Storage::Table::Query.new .from(table_name) .where("CustomIntegerProperty gt #{entity_properties['CustomIntegerProperty']}") .where("CustomBooleanProperty eq true") result = q.execute - result.must_be_kind_of Array - result.length.must_equal 0 + _(result).must_be_kind_of Array + _(result.length).must_equal 0 end it "can limit the result set using the top parameter" do @@ -165,9 +165,9 @@ describe Azure::Storage::Table::TableService do .top(3) result = q.execute - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil end it "can page results using the top parameter and continuation_token" do @@ -176,9 +176,9 @@ describe Azure::Storage::Table::TableService do .top(3) result = q.execute - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil q = Azure::Storage::Table::Query.new .from(table_name) @@ -187,9 +187,9 @@ describe Azure::Storage::Table::TableService do .next_partition(result.continuation_token[:next_partition_key]) result2 = q.execute - result2.must_be_kind_of Array - result2.length.must_equal 3 - result2.continuation_token.wont_be_nil + _(result2).must_be_kind_of Array + _(result2.length).must_equal 3 + _(result2.continuation_token).wont_be_nil q = Azure::Storage::Table::Query.new .from(table_name) @@ -198,9 +198,9 @@ describe Azure::Storage::Table::TableService do .next_partition(result2.continuation_token[:next_partition_key]) result3 = q.execute - result3.must_be_kind_of Array - result3.length.must_equal 3 - result3.continuation_token.wont_be_nil + _(result3).must_be_kind_of Array + _(result3.length).must_equal 3 + _(result3.continuation_token).wont_be_nil q = Azure::Storage::Table::Query.new .from(table_name) @@ -209,9 +209,9 @@ describe Azure::Storage::Table::TableService do .next_partition(result3.continuation_token[:next_partition_key]) result4 = q.execute - result4.must_be_kind_of Array - result4.length.must_equal 3 - result4.continuation_token.must_be_nil + _(result4).must_be_kind_of Array + _(result4.length).must_equal 3 + _(result4.continuation_token).must_be_nil end it "can combine projection, filtering, and paging in the same query" do @@ -229,32 +229,32 @@ describe Azure::Storage::Table::TableService do .top(3) result = q.execute - result.must_be_kind_of Array - result.length.must_equal 3 - result.continuation_token.wont_be_nil + _(result).must_be_kind_of Array + _(result.length).must_equal 3 + _(result.continuation_token).wont_be_nil - result.first.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"] - result.first.properties["PartitionKey"].wont_be_nil - result.first.properties.length.must_equal 2 + _(result.first.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"] + _(result.first.properties["PartitionKey"]).wont_be_nil + _(result.first.properties.length).must_equal 2 q.next_row(result.continuation_token[:next_row_key]).next_partition(result.continuation_token[:next_partition_key]) result2 = q.execute - result2.must_be_kind_of Array - result2.length.must_equal 3 - result2.continuation_token.wont_be_nil + _(result2).must_be_kind_of Array + _(result2.length).must_equal 3 + _(result2.continuation_token).wont_be_nil q.next_row(result2.continuation_token[:next_row_key]).next_partition(result2.continuation_token[:next_partition_key]) result3 = q.execute - result3.must_be_kind_of Array - result3.length.must_equal 3 - result3.continuation_token.wont_be_nil + _(result3).must_be_kind_of Array + _(result3.length).must_equal 3 + _(result3.continuation_token).wont_be_nil q.next_row(result3.continuation_token[:next_row_key]).next_partition(result3.continuation_token[:next_partition_key]) result4 = q.execute - result4.must_be_kind_of Array - result4.length.must_equal 3 - result4.continuation_token.must_be_nil + _(result4).must_be_kind_of Array + _(result4.length).must_equal 3 + _(result4.continuation_token).must_be_nil end end end diff --git a/test/integration/table/table_acl_test.rb b/test/integration/table/table_acl_test.rb index 24f828f2e6580850a4a238923cbd73e1590f39ec..f19b4ad254fa925f59f61ead0238df4045b20124 100644 --- a/test/integration/table/table_acl_test.rb +++ b/test/integration/table/table_acl_test.rb @@ -47,14 +47,14 @@ describe Azure::Storage::Table::TableService do subject.set_table_acl(table_name, signed_identifiers: [ signed_identifier ]) result = subject.get_table_acl table_name - result.must_be_kind_of Array + _(result).must_be_kind_of Array result.wont_be_empty - result.last.must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier - result.last.id.must_equal signed_identifier.id - result.last.access_policy.start.must_equal signed_identifier.access_policy.start - result.last.access_policy.expiry.must_equal signed_identifier.access_policy.expiry - result.last.access_policy.permission.must_equal signed_identifier.access_policy.permission + _(result.last).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(result.last.id).must_equal signed_identifier.id + _(result.last.access_policy.start).must_equal signed_identifier.access_policy.start + _(result.last.access_policy.expiry).must_equal signed_identifier.access_policy.expiry + _(result.last.access_policy.permission).must_equal signed_identifier.access_policy.permission end end end diff --git a/test/integration/table/table_gb18030_test.rb b/test/integration/table/table_gb18030_test.rb index 8c14cf611758bcc61c8128b0cf3b475c9fd3f011..331b8c38234ce7efe42f02d0b2c99fc5489d5c4f 100644 --- a/test/integration/table/table_gb18030_test.rb +++ b/test/integration/table/table_gb18030_test.rb @@ -78,12 +78,12 @@ describe "Table GB-18030" do } result = subject.insert_entity table_name, entity_properties subject.insert_entity table_name, entity_properties2 - result.properties[prop].must_equal "value" + _(result.properties[prop]).must_equal "value" if (k != "Chinese_2B5" && k != "Tibetan") then filter = prop + " eq 'value'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties[prop].must_equal "value" + _(result.length).must_equal 1 + _(result.first.properties[prop]).must_equal "value" end } end @@ -106,12 +106,12 @@ describe "Table GB-18030" do result = subject.insert_entity table_name, entity_properties subject.insert_entity table_name, entity_properties2 - result.properties[prop.encode("UTF-8")].must_equal "value" + _(result.properties[prop.encode("UTF-8")]).must_equal "value" if (k != "Chinese_2B5" && k != "Tibetan") then filter = prop + " eq 'value'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties[prop.encode("UTF-8")].must_equal "value" + _(result.length).must_equal 1 + _(result.first.properties[prop.encode("UTF-8")]).must_equal "value" end } end @@ -133,11 +133,11 @@ describe "Table GB-18030" do } result = subject.insert_entity table_name, entity_properties subject.insert_entity table_name, entity_properties2 - result.properties["Value"].must_equal value + _(result.properties["Value"]).must_equal value filter = "Value eq '" + value + "'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties["Value"].must_equal value + _(result.length).must_equal 1 + _(result.first.properties["Value"]).must_equal value } end @@ -158,11 +158,11 @@ describe "Table GB-18030" do } result = subject.insert_entity table_name, entity_properties subject.insert_entity table_name, entity_properties2 - result.properties["Value"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.properties["Value"].encode("UTF-8")).must_equal value.encode("UTF-8") filter = "Value eq '" + value + "'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties["Value"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.length).must_equal 1 + _(result.first.properties["Value"].encode("UTF-8")).must_equal value.encode("UTF-8") } end @@ -174,20 +174,20 @@ describe "Table GB-18030" do "RowKey" => value, } result = subject.insert_entity table_name, entity_properties - result.properties["PartitionKey"].must_equal value - result.properties["RowKey"].must_equal value + _(result.properties["PartitionKey"]).must_equal value + _(result.properties["RowKey"]).must_equal value if k != "ChineseExtB" then # Service does not support surrogates in key in URL result = subject.get_entity(table_name, value, value) - result.properties["PartitionKey"].must_equal value - result.properties["RowKey"].must_equal value + _(result.properties["PartitionKey"]).must_equal value + _(result.properties["RowKey"]).must_equal value subject.delete_entity(table_name, value, value) begin # Expect error because the entity should be gone result = subject.get_entity(table_name, value, value) flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 404 + _(error.status_code).must_equal 404 end end } @@ -201,19 +201,19 @@ describe "Table GB-18030" do "RowKey" => value.encode("UTF-8") } result = subject.insert_entity table_name, entity_properties - result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") if k != "ChineseExtB" then result = subject.get_entity(table_name, value, value) - result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") subject.delete_entity(table_name, value, value) begin # Expect error because the entity should be gone result = subject.get_entity(table_name, value, value) flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 404 + _(error.status_code).must_equal 404 end end } @@ -230,12 +230,12 @@ describe "Table GB-18030" do batch.insert k + counter.to_s, prop => "value" batch.insert k + counter.to_s + "2", prop => "value2" results = subject.execute_batch batch - results[0].properties[prop].must_equal "value" + _(results[0].properties[prop]).must_equal "value" if (k != "Chinese_2B5" && k != "Tibetan") then filter = prop + " eq 'value'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties[prop.encode("UTF-8")].must_equal "value" + _(result.length).must_equal 1 + _(result.first.properties[prop.encode("UTF-8")]).must_equal "value" end } end @@ -249,12 +249,12 @@ describe "Table GB-18030" do batch.insert k + counter.to_s, prop => "value" batch.insert k + counter.to_s + "2", prop => "value2" results = subject.execute_batch batch - results[0].properties[prop.encode("UTF-8")].must_equal "value" + _(results[0].properties[prop.encode("UTF-8")]).must_equal "value" if (k != "Chinese_2B5" && k != "Tibetan") then filter = prop + " eq 'value'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties[prop.encode("UTF-8")].must_equal "value" + _(result.length).must_equal 1 + _(result.first.properties[prop.encode("UTF-8")]).must_equal "value" end } end @@ -268,11 +268,11 @@ describe "Table GB-18030" do batch.insert k + counter.to_s, "key" => value batch.insert k + counter.to_s + "2", "key" => value + "2" results = subject.execute_batch batch - results[0].properties["key"].must_equal value + _(results[0].properties["key"]).must_equal value filter = "key eq '" + value + "'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties["key"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.length).must_equal 1 + _(result.first.properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8") } end @@ -285,11 +285,11 @@ describe "Table GB-18030" do batch.insert k + counter.to_s, "key" => value batch.insert k + counter.to_s + "2", "key" => value + "2" results = subject.execute_batch batch - results[0].properties["key"].encode("UTF-8").must_equal value.encode("UTF-8") + _(results[0].properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8") filter = "key eq '" + value + "'" result = subject.query_entities table_name, filter: filter - result.length.must_equal 1 - result.first.properties["key"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.length).must_equal 1 + _(result.first.properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8") } end @@ -302,13 +302,13 @@ describe "Table GB-18030" do batch.insert value, {} batch.insert value + "2", {} results = subject.execute_batch batch - results[0].properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - results[0].properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(results[0].properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(results[0].properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") if k != "ChineseExtB" then # Service does not support surrogates in key in URL result = subject.get_entity(table_name, value, value) - result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") end batch = Azure::Storage::Table::Batch.new table_name, value batch.delete value @@ -321,7 +321,7 @@ describe "Table GB-18030" do result = subject.get_entity(table_name, value, value) flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 404 + _(error.status_code).must_equal 404 end end } @@ -336,13 +336,13 @@ describe "Table GB-18030" do batch.insert value, {} batch.insert value + "2", {} results = subject.execute_batch batch - results[0].properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - results[0].properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(results[0].properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(results[0].properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") if k != "ChineseExtB" then # Service does not support surrogates in key in URL result = subject.get_entity(table_name, value, value) - result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8") - result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8") + _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8") + _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8") end batch = Azure::Storage::Table::Batch.new table_name, value batch.delete value @@ -355,7 +355,7 @@ describe "Table GB-18030" do result = subject.get_entity(table_name, value, value) flunk "No exception" rescue Azure::Core::Http::HTTPError => error - error.status_code.must_equal 404 + _(error.status_code).must_equal 404 end end } diff --git a/test/integration/table/table_service_stats_test.rb b/test/integration/table/table_service_stats_test.rb index f91c6a54fa18431177409022dc4e6b7709088941..4daa98be071cac54a033e725b99f672eb757ee27 100644 --- a/test/integration/table/table_service_stats_test.rb +++ b/test/integration/table/table_service_stats_test.rb @@ -31,9 +31,9 @@ describe Azure::Storage::Table::TableService do describe "#get_service_stats" do it "gets service stats" do stats = subject.get_service_stats - stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication - stats.geo_replication.status.must_equal "live" - stats.geo_replication.last_sync_time.must_be_kind_of Time + _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication + _(stats.geo_replication.status).must_equal "live" + _(stats.geo_replication.last_sync_time).must_be_kind_of Time end end end diff --git a/test/integration/table/update_entity_batch_test.rb b/test/integration/table/update_entity_batch_test.rb index f4399ba5248b7aa93996e723de619289961f79d7..5dae48533fee68d44e25376ef4740ef89a79dcfc 100644 --- a/test/integration/table/update_entity_batch_test.rb +++ b/test/integration/table/update_entity_batch_test.rb @@ -66,12 +66,12 @@ describe Azure::Storage::Table::TableService do etags = subject.execute_batch batch # etag for first (and only) operation - etags[0].must_be_kind_of String + _(etags[0]).must_be_kind_of String etags[0].wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity_properties.each { |k, v| @@ -79,7 +79,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "updates an existing entity, removing any properties not included in the update operation and adding nil one" do @@ -90,12 +90,12 @@ describe Azure::Storage::Table::TableService do etags = subject.execute_batch batch # etag for first (and only) operation - etags[0].must_be_kind_of String + _(etags[0]).must_be_kind_of String etags[0].wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity_properties.each { |k, v| @@ -103,7 +103,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal nil + _(result.properties["NewCustomProperty"]).must_equal nil end it "errors on a non-existing row key" do diff --git a/test/integration/table/update_entity_test.rb b/test/integration/table/update_entity_test.rb index 9a6fda3a572372d02f5d61b62b8574862efe9952..0f3ebb4648f0c7fd62429bf8ce959725406e7a51 100644 --- a/test/integration/table/update_entity_test.rb +++ b/test/integration/table/update_entity_test.rb @@ -63,12 +63,12 @@ describe Azure::Storage::Table::TableService do RowKey: entity_properties["RowKey"], NewCustomProperty: "NewCustomValue" - etag.must_be_kind_of String + _(etag).must_be_kind_of String etag.wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity_properties.each { |k, v| @@ -76,7 +76,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal "NewCustomValue" + _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue" end it "updates an existing entity, removing any properties not included in the update operation and adding nil one" do @@ -84,12 +84,12 @@ describe Azure::Storage::Table::TableService do RowKey: entity_properties["RowKey"], NewCustomProperty: nil - etag.must_be_kind_of String + _(etag).must_be_kind_of String etag.wont_equal @existing_etag result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"] - result.must_be_kind_of Azure::Storage::Table::Entity + _(result).must_be_kind_of Azure::Storage::Table::Entity # removed all existing props entity_properties.each { |k, v| @@ -97,7 +97,7 @@ describe Azure::Storage::Table::TableService do } # and has the new one - result.properties["NewCustomProperty"].must_equal nil + _(result.properties["NewCustomProperty"]).must_equal nil end it "errors on a non-existing row key" do diff --git a/test/unit/blob/blob_service_test.rb b/test/unit/blob/blob_service_test.rb index d3c39f6acc85df31be741c909188bd97d3d301dd..fd98c03833a32277a1427d042df2ccd18c29a203 100644 --- a/test/unit/blob/blob_service_test.rb +++ b/test/unit/blob/blob_service_test.rb @@ -74,7 +74,7 @@ describe Azure::Storage::Blob::BlobService do it "returns a list of containers for the account" do result = subject.list_containers - result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults + _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults end describe "when the options Hash is used" do @@ -168,8 +168,8 @@ describe Azure::Storage::Blob::BlobService do it "returns a new container" do result = subject.create_container container_name - result.must_be_kind_of Azure::Storage::Blob::Container::Container - result.name.must_equal container_name + _(result).must_be_kind_of Azure::Storage::Blob::Container::Container + _(result.name).must_equal container_name end describe "when optional metadata parameter is used" do @@ -233,7 +233,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.delete_container container_name - result.must_equal nil + _(result).must_equal nil end end @@ -267,9 +267,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a container, with it's properties attribute populated" do result = subject.get_container_properties container_name - result.must_be_kind_of Azure::Storage::Blob::Container::Container - result.name.must_equal container_name - result.properties.must_equal container_properties + _(result).must_be_kind_of Azure::Storage::Blob::Container::Container + _(result.name).must_equal container_name + _(result.properties).must_equal container_properties end end @@ -306,9 +306,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a container, with it's metadata attribute populated" do result = subject.get_container_metadata container_name - result.must_be_kind_of Azure::Storage::Blob::Container::Container - result.name.must_equal container_name - result.metadata.must_equal container_metadata + _(result).must_be_kind_of Azure::Storage::Blob::Container::Container + _(result.name).must_equal container_name + _(result.metadata).must_equal container_metadata end end @@ -348,11 +348,11 @@ describe Azure::Storage::Blob::BlobService do it "returns a container and an ACL" do returned_container, returned_acl = subject.get_container_acl container_name - returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container - returned_container.name.must_equal container_name + _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container + _(returned_container.name).must_equal container_name - returned_acl.must_be_kind_of Array - returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(returned_acl).must_be_kind_of Array + _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier end end @@ -389,11 +389,11 @@ describe Azure::Storage::Blob::BlobService do it "returns a container and an ACL" do returned_container, returned_acl = subject.set_container_acl container_name, public_access_level - returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container - returned_container.name.must_equal container_name - returned_container.public_access_level.must_equal public_access_level + _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container + _(returned_container.name).must_equal container_name + _(returned_container.public_access_level).must_equal public_access_level - returned_acl.must_be_kind_of Array + _(returned_acl).must_be_kind_of Array end describe "when the public_access_level parameter is set to 'container'" do @@ -427,12 +427,12 @@ describe Azure::Storage::Blob::BlobService do subject.stubs(:call).with(verb, uri, request_body, request_headers, options).returns(response) returned_container, returned_acl = subject.set_container_acl container_name, public_access_level, options - returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container - returned_container.name.must_equal container_name - returned_container.public_access_level.must_equal public_access_level + _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container + _(returned_container.name).must_equal container_name + _(returned_container.public_access_level).must_equal public_access_level - returned_acl.must_be_kind_of Array - returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(returned_acl).must_be_kind_of Array + _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier end end end @@ -490,7 +490,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.set_container_metadata container_name, container_metadata - result.must_equal nil + _(result).must_equal nil end end @@ -524,7 +524,7 @@ describe Azure::Storage::Blob::BlobService do it "returns a list of blobs for the container" do result = subject.list_blobs container_name - result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults + _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults end describe "when the options Hash is used" do @@ -662,9 +662,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a Blob on success" do result = subject.create_page_blob container_name, blob_name, blob_length - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when the options Hash is used" do @@ -772,8 +772,8 @@ describe Azure::Storage::Blob::BlobService do it "returns 'x-ms-copy-id' and 'x-ms-copy-status' on success" do result = subject.incremental_copy_blob container_name, blob_name, source_uri - result[0].must_equal copy_id - result[1].must_equal copy_status + _(result[0]).must_equal copy_id + _(result[1]).must_equal copy_status end end @@ -809,9 +809,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a Blob on success" do result = subject.put_blob_pages container_name, blob_name, start_range, end_range, content - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when the options Hash is used" do @@ -904,9 +904,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a Blob on success" do result = subject.clear_blob_pages container_name, blob_name, start_range, end_range - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end # describe "when start_range is provided" do @@ -967,7 +967,7 @@ describe Azure::Storage::Blob::BlobService do it "returns content MD5 on success" do result = subject.put_blob_block container_name, blob_name, block_id, content - result.must_equal server_generated_content_md5 + _(result).must_equal server_generated_content_md5 end describe "when the options Hash is used" do @@ -1013,9 +1013,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a Blob on success" do result = subject.create_block_blob container_name, blob_name, content - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when the options Hash is used" do @@ -1115,7 +1115,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.commit_blob_blocks container_name, blob_name, block_list - result.must_equal nil + _(result).must_equal nil end describe "when the options Hash is used" do @@ -1248,8 +1248,8 @@ describe Azure::Storage::Blob::BlobService do local_call_options = { blocklist_type: :all }.merge options subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri) result = subject.list_blob_blocks container_name, blob_name - result.must_be_kind_of Array - result.first.must_be_kind_of Azure::Storage::Blob::Block + _(result).must_be_kind_of Array + _(result.first).must_be_kind_of Azure::Storage::Blob::Block end describe "when blocklist_type is provided" do @@ -1319,10 +1319,10 @@ describe Azure::Storage::Blob::BlobService do it "returns a list of ranges for the page blob" do result = subject.list_page_blob_ranges container_name, blob_name - result.must_be_kind_of Array - result.first.must_be_kind_of Array - result.first.first.must_be_kind_of Integer - result.first.first.next.must_be_kind_of Integer + _(result).must_be_kind_of Array + _(result.first).must_be_kind_of Array + _(result.first.first).must_be_kind_of Integer + _(result.first.first.next).must_be_kind_of Integer end # describe "when start_range is provided" do @@ -1560,9 +1560,9 @@ describe Azure::Storage::Blob::BlobService do it "returns a Blob on success" do result = subject.create_append_blob container_name, blob_name - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when the options Hash is used" do @@ -1773,7 +1773,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.set_blob_properties container_name, blob_name - result.must_equal nil + _(result).must_equal nil end describe "when the options Hash is used" do @@ -1873,7 +1873,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.set_blob_metadata container_name, blob_name, blob_metadata - result.must_equal nil + _(result).must_equal nil end end @@ -1901,9 +1901,9 @@ describe Azure::Storage::Blob::BlobService do it "returns the blob on success" do result = subject.get_blob_properties container_name, blob_name - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when snapshot is provided" do @@ -1922,7 +1922,7 @@ describe Azure::Storage::Blob::BlobService do subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri) subject.stubs(:call).with(verb, uri, nil, request_headers, local_call_options).returns(response) result = subject.get_blob_properties container_name, blob_name, local_call_options - result.snapshot.must_equal snapshot + _(result.snapshot).must_equal snapshot end end end @@ -1953,9 +1953,9 @@ describe Azure::Storage::Blob::BlobService do it "returns the blob on success" do result = subject.get_blob_metadata container_name, blob_name - result.must_be_kind_of Azure::Storage::Blob::Blob - result.must_equal blob - result.name.must_equal blob_name + _(result).must_be_kind_of Azure::Storage::Blob::Blob + _(result).must_equal blob + _(result.name).must_equal blob_name end describe "when snapshot is provided" do @@ -1977,7 +1977,7 @@ describe Azure::Storage::Blob::BlobService do subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri) subject.stubs(:call).with(verb, uri, nil, request_headers, local_call_options).returns(response) result = subject.get_blob_metadata container_name, blob_name, local_call_options - result.snapshot.must_equal snapshot + _(result.snapshot).must_equal snapshot end end end @@ -2007,10 +2007,10 @@ describe Azure::Storage::Blob::BlobService do it "returns the blob and blob contents on success" do returned_blob, returned_blob_contents = subject.get_blob container_name, blob_name - returned_blob.must_be_kind_of Azure::Storage::Blob::Blob - returned_blob.must_equal blob + _(returned_blob).must_be_kind_of Azure::Storage::Blob::Blob + _(returned_blob).must_equal blob - returned_blob_contents.must_equal response_body + _(returned_blob_contents).must_equal response_body end describe "when snapshot is provided" do @@ -2113,7 +2113,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.delete_blob container_name, blob_name - result.must_equal nil + _(result).must_equal nil end describe "when snapshot is provided" do @@ -2197,8 +2197,8 @@ describe Azure::Storage::Blob::BlobService do it "returns the snapshot id on success" do result = subject.create_blob_snapshot container_name, blob_name - result.must_be_kind_of String - result.must_equal snapshot_id + _(result).must_be_kind_of String + _(result).must_equal snapshot_id end describe "when the options Hash is used" do @@ -2289,8 +2289,8 @@ describe Azure::Storage::Blob::BlobService do it "returns the copy id and copy status on success" do returned_copy_id, returned_copy_status = subject.copy_blob container_name, blob_name, source_container_name, source_blob_name - returned_copy_id.must_equal copy_id - returned_copy_status.must_equal copy_status + _(returned_copy_id).must_equal copy_id + _(returned_copy_status).must_equal copy_status end describe "when snapshot is provided" do @@ -2439,7 +2439,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease id on success" do result = subject.acquire_blob_lease container_name, blob_name - result.must_equal lease_id + _(result).must_equal lease_id end describe "when passed a duration" do @@ -2487,7 +2487,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease id on success" do result = subject.renew_blob_lease container_name, blob_name, lease_id - result.must_equal lease_id + _(result).must_equal lease_id end end @@ -2514,7 +2514,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease id on success" do result = subject.change_blob_lease container_name, blob_name, lease_id, proposed_lease_id - result.must_equal proposed_lease_id + _(result).must_equal proposed_lease_id end end @@ -2538,7 +2538,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.release_blob_lease container_name, blob_name, lease_id - result.must_equal nil + _(result).must_equal nil end end @@ -2563,7 +2563,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease time on success" do result = subject.break_blob_lease container_name, blob_name - result.must_equal lease_time + _(result).must_equal lease_time end describe "when passed an optional break period" do @@ -2599,7 +2599,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease id on success" do result = subject.acquire_container_lease container_name - result.must_equal lease_id + _(result).must_equal lease_id end describe "when passed a duration" do @@ -2647,7 +2647,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease id on success" do result = subject.renew_container_lease container_name, lease_id - result.must_equal lease_id + _(result).must_equal lease_id end end @@ -2671,7 +2671,7 @@ describe Azure::Storage::Blob::BlobService do it "returns nil on success" do result = subject.release_container_lease container_name, lease_id - result.must_equal nil + _(result).must_equal nil end end @@ -2696,7 +2696,7 @@ describe Azure::Storage::Blob::BlobService do it "returns lease time on success" do result = subject.break_container_lease container_name - result.must_equal lease_time + _(result).must_equal lease_time end describe "when passed an optional break period" do @@ -2743,53 +2743,53 @@ describe Azure::Storage::Blob::BlobService do describe "#containers_uri" do it "returns a containers URI" do result = subject.containers_uri - result.must_be_kind_of URI - result.scheme.must_equal "http" - result.host.must_equal "dummy.uri" - result.path.must_equal "/" - result.query.must_equal "comp=list" + _(result).must_be_kind_of URI + _(result.scheme).must_equal "http" + _(result.host).must_equal "dummy.uri" + _(result.path).must_equal "/" + _(result.query).must_equal "comp=list" end it "encodes optional query has as uri parameters" do result = subject.containers_uri query - result.query.must_equal "comp=list¶m=value¶m+1=value+1" + _(result.query).must_equal "comp=list¶m=value¶m+1=value+1" end end describe "#container_uri" do it "returns a container URI" do result = subject.container_uri container_name - result.must_be_kind_of URI - result.scheme.must_equal "http" - result.host.must_equal "dummy.uri" - result.path.must_equal "/container" - result.query.must_equal "restype=container" + _(result).must_be_kind_of URI + _(result.scheme).must_equal "http" + _(result.host).must_equal "dummy.uri" + _(result.path).must_equal "/container" + _(result.query).must_equal "restype=container" end it "encodes optional query has as uri parameters" do result = subject.container_uri container_name, query - result.query.must_equal "restype=container¶m=value¶m+1=value+1" + _(result.query).must_equal "restype=container¶m=value¶m+1=value+1" end it "returns the same URI instance when the first parameter is a URI" do random_uri = URI.parse("http://random.uri") result = subject.container_uri random_uri - result.must_equal random_uri + _(result).must_equal random_uri end end describe "#blob_uri" do it "returns a blob URI" do result = subject.blob_uri container_name, blob_name - result.must_be_kind_of URI - result.scheme.must_equal "http" - result.host.must_equal "dummy.uri" - result.path.must_equal "/container/blob" + _(result).must_be_kind_of URI + _(result.scheme).must_equal "http" + _(result.host).must_equal "dummy.uri" + _(result.path).must_equal "/container/blob" end it "encodes optional query has as uri parameters" do result = subject.blob_uri container_name, blob_name, query - result.query.must_equal "param=value¶m+1=value+1" + _(result.query).must_equal "param=value¶m+1=value+1" end end end diff --git a/test/unit/config/client_services_test.rb b/test/unit/config/client_services_test.rb index 0ae926d72b9eee46767d0340ff3f8f3d859649ae..74b84a2d240208fb68738c4b537f3c450e595719 100644 --- a/test/unit/config/client_services_test.rb +++ b/test/unit/config/client_services_test.rb @@ -33,57 +33,57 @@ describe Azure::Storage::Common::Client do it "storage host should be set to default" do subject = Azure::Storage::Common::Client.create(storage_account_name: azure_storage_account, storage_access_key: azure_storage_access_key) - subject.storage_account_name.must_equal azure_storage_account - subject.storage_access_key.must_equal azure_storage_access_key - subject.storage_blob_host.must_equal "https://#{azure_storage_account}.blob.core.windows.net" - subject.storage_blob_host(true).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net" - subject.storage_table_host.must_equal "https://#{azure_storage_account}.table.core.windows.net" - subject.storage_table_host(true).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net" - subject.storage_queue_host.must_equal "https://#{azure_storage_account}.queue.core.windows.net" - subject.storage_queue_host(true).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net" - subject.storage_file_host.must_equal "https://#{azure_storage_account}.file.core.windows.net" - subject.storage_file_host(true).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net" - subject.signer.must_be_nil + _(subject.storage_account_name).must_equal azure_storage_account + _(subject.storage_access_key).must_equal azure_storage_access_key + _(subject.storage_blob_host).must_equal "https://#{azure_storage_account}.blob.core.windows.net" + _(subject.storage_blob_host(true)).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net" + _(subject.storage_table_host).must_equal "https://#{azure_storage_account}.table.core.windows.net" + _(subject.storage_table_host(true)).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net" + _(subject.storage_queue_host).must_equal "https://#{azure_storage_account}.queue.core.windows.net" + _(subject.storage_queue_host(true)).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net" + _(subject.storage_file_host).must_equal "https://#{azure_storage_account}.file.core.windows.net" + _(subject.storage_file_host(true)).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net" + _(subject.signer).must_be_nil end it "storage sas works" do subject = Azure::Storage::Common::Client.create(storage_account_name: azure_storage_account, storage_sas_token: storage_sas_token) - subject.storage_account_name.must_equal azure_storage_account - subject.storage_sas_token.must_equal storage_sas_token - subject.storage_blob_host.must_equal "https://#{azure_storage_account}.blob.core.windows.net" - subject.storage_blob_host(true).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net" - subject.storage_table_host.must_equal "https://#{azure_storage_account}.table.core.windows.net" - subject.storage_table_host(true).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net" - subject.storage_queue_host.must_equal "https://#{azure_storage_account}.queue.core.windows.net" - subject.storage_queue_host(true).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net" - subject.storage_file_host.must_equal "https://#{azure_storage_account}.file.core.windows.net" - subject.storage_file_host(true).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net" - subject.signer.wont_be_nil - subject.signer.class.must_equal Azure::Storage::Common::Core::Auth::SharedAccessSignatureSigner + _(subject.storage_account_name).must_equal azure_storage_account + _(subject.storage_sas_token).must_equal storage_sas_token + _(subject.storage_blob_host).must_equal "https://#{azure_storage_account}.blob.core.windows.net" + _(subject.storage_blob_host(true)).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net" + _(subject.storage_table_host).must_equal "https://#{azure_storage_account}.table.core.windows.net" + _(subject.storage_table_host(true)).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net" + _(subject.storage_queue_host).must_equal "https://#{azure_storage_account}.queue.core.windows.net" + _(subject.storage_queue_host(true)).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net" + _(subject.storage_file_host).must_equal "https://#{azure_storage_account}.file.core.windows.net" + _(subject.storage_file_host(true)).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net" + _(subject.signer).wont_be_nil + _(subject.signer.class).must_equal Azure::Storage::Common::Core::Auth::SharedAccessSignatureSigner end it "storage development works" do subject = Azure::Storage::Common::Client.create_development - subject.storage_account_name.must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT - subject.storage_access_key.must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY + _(subject.storage_account_name).must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT + _(subject.storage_access_key).must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY proxy_uri = Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI - subject.storage_blob_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_BLOB_HOST_PORT}" - subject.storage_table_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_TABLE_HOST_PORT}" - subject.storage_queue_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_QUEUE_HOST_PORT}" - subject.storage_file_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_FILE_HOST_PORT}" - subject.signer.must_be_nil + _(subject.storage_blob_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_BLOB_HOST_PORT}" + _(subject.storage_table_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_TABLE_HOST_PORT}" + _(subject.storage_queue_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_QUEUE_HOST_PORT}" + _(subject.storage_file_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_FILE_HOST_PORT}" + _(subject.signer).must_be_nil end it "storage from env && storage from connection_string works" do subjectA = Azure::Storage::Common::Client.create_from_env subjectB = Azure::Storage::Common::Client.create_from_connection_string(ENV["AZURE_STORAGE_CONNECTION_STRING"]) - subjectA.storage_account_name.must_equal subjectB.storage_account_name - subjectA.storage_access_key.must_equal subjectB.storage_access_key - subjectA.storage_sas_token.must_equal subjectB.storage_sas_token - subjectA.storage_blob_host.must_equal subjectB.storage_blob_host - subjectA.storage_table_host.must_equal subjectB.storage_table_host - subjectA.storage_queue_host.must_equal subjectB.storage_queue_host - subjectA.storage_file_host.must_equal subjectB.storage_file_host + _(subjectA.storage_account_name).must_equal subjectB.storage_account_name + _(subjectA.storage_access_key).must_equal subjectB.storage_access_key + _(subjectA.storage_sas_token).must_equal subjectB.storage_sas_token + _(subjectA.storage_blob_host).must_equal subjectB.storage_blob_host + _(subjectA.storage_table_host).must_equal subjectB.storage_table_host + _(subjectA.storage_queue_host).must_equal subjectB.storage_queue_host + _(subjectA.storage_file_host).must_equal subjectB.storage_file_host end end end diff --git a/test/unit/config/client_test.rb b/test/unit/config/client_test.rb index 464316734f7e0675d13c60fa40b63905766019da..8a3c13f491ed5f23863b778ecbaba3cf2765610b 100644 --- a/test/unit/config/client_test.rb +++ b/test/unit/config/client_test.rb @@ -74,22 +74,22 @@ describe Azure::Storage::Common::Client do it "should fail with nil params or call create_from_env directly" do removed = clear_storage_instance_variables - lambda { Azure::Storage::Common::Client.create }.must_raise(Azure::Storage::Common::InvalidOptionsError) - lambda { Azure::Storage::Common::Client.new }.must_raise(Azure::Storage::Common::InvalidOptionsError) - lambda { Azure::Storage::Common::Client.create_from_env }.must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.create }).must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.new }).must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.create_from_env }).must_raise(Azure::Storage::Common::InvalidOptionsError) restore_storage_instance_variables removed end it "should fail with empty Hash" do removed = clear_storage_instance_variables - lambda { Azure::Storage::Common::Client.create({}) }.must_raise(Azure::Storage::Common::InvalidOptionsError) - lambda { Azure::Storage::Common::Client.new({}) }.must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.create({}) }).must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.new({}) }).must_raise(Azure::Storage::Common::InvalidOptionsError) restore_storage_instance_variables removed end it "should fail with empty connection string" do removed = clear_storage_instance_variables - lambda { Azure::Storage::Common::Client.create_from_connection_string("") }.must_raise(Azure::Storage::Common::InvalidConnectionStringError) + _(lambda { Azure::Storage::Common::Client.create_from_connection_string("") }).must_raise(Azure::Storage::Common::InvalidConnectionStringError) restore_storage_instance_variables removed end @@ -103,11 +103,11 @@ describe Azure::Storage::Common::Client do client3 = Azure::Storage::Common::Client.create_development(@devstore_options[:development_storage_proxy_uri]) [client1, client2, client3].each do |c| - c.wont_be_nil - c.storage_account_name.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT) - c.storage_access_key.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY) - c.storage_blob_host.must_include(@devstore_options[:development_storage_proxy_uri]) - c.use_path_style_uri.must_equal(true) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT) + _(c.storage_access_key).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY) + _(c.storage_blob_host).must_include(@devstore_options[:development_storage_proxy_uri]) + _(c.use_path_style_uri).must_equal(true) end end @@ -121,10 +121,10 @@ describe Azure::Storage::Common::Client do restore_storage_instance_variables removed [client1, client2, client3, client4].each do |c| - c.wont_be_nil - c.storage_account_name.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT) - c.storage_access_key.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY) - c.storage_blob_host.must_include(Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT) + _(c.storage_access_key).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY) + _(c.storage_blob_host).must_include(Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI) end ENV.delete("EMULATED") @@ -139,45 +139,45 @@ describe Azure::Storage::Common::Client do client2 = Azure::Storage::Common::Client.create_from_connection_string(get_connection_string(@account_key_options)) [client1, client2].each do |c| - c.wont_be_nil - c.storage_account_name.must_equal(@account_name) - c.storage_access_key.must_equal(@access_key) - c.storage_table_host.must_include(Azure::Storage::Common::StorageServiceClientConstants::DEFAULT_ENDPOINT_SUFFIX) - c.default_endpoints_protocol.must_equal("https") - c.use_path_style_uri.must_equal(false) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(@account_name) + _(c.storage_access_key).must_equal(@access_key) + _(c.storage_table_host).must_include(Azure::Storage::Common::StorageServiceClientConstants::DEFAULT_ENDPOINT_SUFFIX) + _(c.default_endpoints_protocol).must_equal("https") + _(c.use_path_style_uri).must_equal(false) end end it "should set hosts differently if suffix is set" do c = Azure::Storage::Common::Client.new(@account_key_suffix_options) - c.wont_be_nil - c.storage_account_name.must_equal(@account_name) - c.storage_access_key.must_equal(@access_key) - c.storage_queue_host.must_include(@account_key_suffix_options[:storage_dns_suffix]) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(@account_name) + _(c.storage_access_key).must_equal(@access_key) + _(c.storage_queue_host).must_include(@account_key_suffix_options[:storage_dns_suffix]) end it "should set scheme if protocol is set" do c = Azure::Storage::Common::Client.create(@account_key_protocol_options) - c.wont_be_nil - c.storage_account_name.must_equal(@account_name) - c.storage_access_key.must_equal(@access_key) - c.default_endpoints_protocol.must_equal("http") - c.storage_blob_host.must_include("http://") + _(c).wont_be_nil + _(c.storage_account_name).must_equal(@account_name) + _(c.storage_access_key).must_equal(@access_key) + _(c.default_endpoints_protocol).must_equal("http") + _(c.storage_blob_host).must_include("http://") end it "should set host if given" do opts = @account_key_options.merge(storage_blob_host: @mock_blob_host_with_protocol) c = Azure::Storage::Common::Client.new(get_connection_string(opts)) - c.wont_be_nil - c.storage_account_name.must_equal(@account_name) - c.storage_access_key.must_equal(@access_key) - lambda { c.default_endpoints_protocol }.must_raise(NoMethodError) - c.storage_blob_host.must_equal(@mock_blob_host_with_protocol) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(@account_name) + _(c.storage_access_key).must_equal(@access_key) + _(lambda { c.default_endpoints_protocol }).must_raise(NoMethodError) + _(c.storage_blob_host).must_equal(@mock_blob_host_with_protocol) end it "should fail host if protocol are dup set" do opts = @account_key_protocol_options.merge(storage_blob_host: @mock_blob_host_with_protocol) - lambda { Azure::Storage::Common::Client.new(opts) }.must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.new(opts) }).must_raise(Azure::Storage::Common::InvalidOptionsError) end end @@ -186,23 +186,23 @@ describe Azure::Storage::Common::Client do it "should succeed if sas_token is given with name" do opts = { storage_account_name: @account_name, storage_sas_token: @mock_sas } c = Azure::Storage::Common::Client.create(opts) - c.wont_be_nil - c.storage_account_name.must_equal(@account_name) - lambda { c.options.storage_access_key }.must_raise(NoMethodError) - c.storage_sas_token.must_equal(@mock_sas) + _(c).wont_be_nil + _(c.storage_account_name).must_equal(@account_name) + _(lambda { c.options.storage_access_key }).must_raise(NoMethodError) + _(c.storage_sas_token).must_equal(@mock_sas) end it "should fail if both sas_token and key" do opts = @account_key_options.merge(storage_sas_token: @mock_sas) - lambda { Azure::Storage::Common::Client.create(opts) }.must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.create(opts) }).must_raise(Azure::Storage::Common::InvalidOptionsError) end it "should succeed if given a host anonymously" do opts = { storage_blob_host: @mock_blob_host_with_protocol } c = Azure::Storage::Common::Client.create(opts) - c.wont_be_nil - c.storage_blob_host.must_equal(@mock_blob_host_with_protocol) - lambda { c.options.storage_queue_host }.must_raise(NoMethodError) + _(c).wont_be_nil + _(c.storage_blob_host).must_equal(@mock_blob_host_with_protocol) + _(lambda { c.options.storage_queue_host }).must_raise(NoMethodError) end end @@ -210,14 +210,14 @@ describe Azure::Storage::Common::Client do it "should fail if no environment variables are set" do removed = clear_storage_instance_variables - lambda { Azure::Storage::Common::Client.create }.must_raise(Azure::Storage::Common::InvalidOptionsError) + _(lambda { Azure::Storage::Common::Client.create }).must_raise(Azure::Storage::Common::InvalidOptionsError) restore_storage_instance_variables removed end it "calls default options to see if valid" do options = Azure::Storage::Common::Default.options for key in Azure::Storage::Common::Configurable::keys - options[key].must_be_nil + _(options[key]).must_be_nil end end @@ -225,9 +225,9 @@ describe Azure::Storage::Common::Client do set_storage_envs(@account_key_options) client = Azure::Storage::Common::Client.create - client.wont_be_nil - client.storage_account_name.must_equal(@account_key_options[:storage_account_name]) - client.storage_access_key.must_equal(@account_key_options[:storage_access_key]) + _(client).wont_be_nil + _(client.storage_account_name).must_equal(@account_key_options[:storage_account_name]) + _(client.storage_access_key).must_equal(@account_key_options[:storage_access_key]) clear_storage_envs end @@ -241,27 +241,27 @@ describe Azure::Storage::Common::Client do let(:common_signer_client) { Azure::Storage::Common::Client.create storage_account_name: @account_name, signer: token_signer } it "should succeed to create blob client if account name and signer are given" do - token_credential.token.must_equal token + _(token_credential.token).must_equal token blob_signer_client = Azure::Storage::Blob::BlobService.new(storage_account_name: @account_name, signer: token_signer) - blob_signer_client.wont_be_nil + _(blob_signer_client).wont_be_nil end it "should succeed to create blob client if common client is given" do - token_credential.token.must_equal token + _(token_credential.token).must_equal token blob_signer_client = Azure::Storage::Blob::BlobService.new(client: common_signer_client, signer: token_signer) - blob_signer_client.wont_be_nil + _(blob_signer_client).wont_be_nil end it "should succeed to create queue client if account name and signer are given" do - token_credential.token.must_equal token + _(token_credential.token).must_equal token queue_signer_client = Azure::Storage::Queue::QueueService.new(storage_account_name: @account_name, signer: token_signer) - queue_signer_client.wont_be_nil + _(queue_signer_client).wont_be_nil end it "should succeed to create queue client if common client is given" do - token_credential.token.must_equal token + _(token_credential.token).must_equal token queue_signer_client = Azure::Storage::Queue::QueueService.new(client: common_signer_client, signer: token_signer) - queue_signer_client.wont_be_nil + _(queue_signer_client).wont_be_nil end end @@ -269,9 +269,9 @@ describe Azure::Storage::Common::Client do describe "when create with ssl options" do it "should set the ssl option correctly" do client1 = Azure::Storage::Common::Client.new(@account_key_options_with_ssl_version) - client1.ssl_version.must_equal(@ssl_version) - client1.ssl_min_version.must_equal(@ssl_min_version) - client1.ssl_max_version.must_equal(@ssl_max_version) + _(client1.ssl_version).must_equal(@ssl_version) + _(client1.ssl_min_version).must_equal(@ssl_min_version) + _(client1.ssl_max_version).must_equal(@ssl_max_version) end end diff --git a/test/unit/core/auth/shared_access_signature_test.rb b/test/unit/core/auth/shared_access_signature_test.rb index a4518cb3ad17f898009a7b4c8ac9e3500169e3ca..db99a1c920e82679a1dd28fc9cf22630ea9a5cb9 100644 --- a/test/unit/core/auth/shared_access_signature_test.rb +++ b/test/unit/core/auth/shared_access_signature_test.rb @@ -63,7 +63,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do describe "#signable_string" do it "constructs a string for service in the required format" do - subject.signable_string_for_service(service_type, path, service_options).must_equal( + _(subject.signable_string_for_service(service_type, path, service_options)).must_equal( "rwd\n#{Time.parse('2020-12-10T00:00:00Z').utc.iso8601}\n#{Time.parse('2020-12-11T00:00:00Z').utc.iso8601}\n" + "/blob/account-name/example/path\n\n168.1.5.60-168.1.5.70\nhttps,http\n#{Azure::Storage::Common::Default::STG_VERSION}\n" + "public\ninline, filename=nyan.cat\ngzip\nEnglish\nbinary" @@ -71,7 +71,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do end it "constructs a string for account in the required format" do - subject.signable_string_for_account(account_options).must_equal( + _(subject.signable_string_for_account(account_options)).must_equal( "account-name\nrwd\nb\nb\n#{Time.parse('2020-12-10T00:00:00Z').utc.iso8601}\n#{Time.parse('2020-12-11T00:00:00Z').utc.iso8601}\n168.1.5.60-168.1.5.70\nhttps,http\n#{Azure::Storage::Common::Default::STG_VERSION}\n" ) end @@ -79,7 +79,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do describe "#canonicalized_resource" do it "prefixes and concatenates account name and resource path with forward slashes" do - subject.canonicalized_resource(service_type, path).must_equal "/blob/account-name/example/path" + _(subject.canonicalized_resource(service_type, path)).must_equal "/blob/account-name/example/path" end end @@ -87,37 +87,37 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do it "maps options to the abbreviated API versions for service" do uri = URI(subject.signed_uri(URI(path), false, service_options)) query_hash = Hash[URI.decode_www_form(uri.query)] - query_hash["sp"].must_equal "rwd" - query_hash["st"].must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601 - query_hash["se"].must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601 - query_hash["sr"].must_equal "b" - query_hash["sip"].must_equal "168.1.5.60-168.1.5.70" - query_hash["spr"].must_equal "https,http" - query_hash["rscc"].must_equal "public" - query_hash["rscd"].must_equal "inline, filename=nyan.cat" - query_hash["rsce"].must_equal "gzip" - query_hash["rscl"].must_equal "English" - query_hash["rsct"].must_equal "binary" + _(query_hash["sp"]).must_equal "rwd" + _(query_hash["st"]).must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601 + _(query_hash["se"]).must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601 + _(query_hash["sr"]).must_equal "b" + _(query_hash["sip"]).must_equal "168.1.5.60-168.1.5.70" + _(query_hash["spr"]).must_equal "https,http" + _(query_hash["rscc"]).must_equal "public" + _(query_hash["rscd"]).must_equal "inline, filename=nyan.cat" + _(query_hash["rsce"]).must_equal "gzip" + _(query_hash["rscl"]).must_equal "English" + _(query_hash["rsct"]).must_equal "binary" end it "maps options to the abbreviated API versions for account" do uri = URI(subject.signed_uri(URI(path), true, account_options)) query_hash = Hash[URI.decode_www_form(uri.query)] - query_hash["ss"].must_equal "b" - query_hash["srt"].must_equal "b" - query_hash["sp"].must_equal "rwd" - query_hash["st"].must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601 - query_hash["se"].must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601 - query_hash["sip"].must_equal "168.1.5.60-168.1.5.70" - query_hash["spr"].must_equal "https,http" + _(query_hash["ss"]).must_equal "b" + _(query_hash["srt"]).must_equal "b" + _(query_hash["sp"]).must_equal "rwd" + _(query_hash["st"]).must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601 + _(query_hash["se"]).must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601 + _(query_hash["sip"]).must_equal "168.1.5.60-168.1.5.70" + _(query_hash["spr"]).must_equal "https,http" end it "correctly maps service type when given full blob url and no service" do blob_url = File.join("https://#{access_account_name}.blob.core.windows.net", path) uri = URI(subject.signed_uri(URI(blob_url), true, account_options.merge(service: nil))) query_hash = Hash[URI.decode_www_form(uri.query)] - query_hash["ss"].must_equal "b" - query_hash["srt"].must_equal "b" + _(query_hash["ss"]).must_equal "b" + _(query_hash["srt"]).must_equal "b" end end end diff --git a/test/unit/core/credential_test.rb b/test/unit/core/credential_test.rb index 80df33123c704d8ac677ea3a835eb03309171bd1..4aa18c775a78f839c742721d0820e42d0861f695 100644 --- a/test/unit/core/credential_test.rb +++ b/test/unit/core/credential_test.rb @@ -44,8 +44,8 @@ describe Azure::Storage::Common::Core::TokenCredential do end threads.each { |t| t.join } - current.wont_be_nil - token_credential.token.must_equal "refreshed_token_#{current}" + _(current).wont_be_nil + _(token_credential.token).must_equal "refreshed_token_#{current}" end end diff --git a/test/unit/core/http/retry_policy_test.rb b/test/unit/core/http/retry_policy_test.rb index 596c0edf042b6e9747739b1191d281093a985145..bf1e7e3133f371a711eb6480a743d9021c4ff877 100644 --- a/test/unit/core/http/retry_policy_test.rb +++ b/test/unit/core/http/retry_policy_test.rb @@ -29,19 +29,19 @@ require "azure/storage/common" describe Azure::Core::Http::RetryPolicy do it "uses blocks as retry logic" do retry_policy = Azure::Core::Http::RetryPolicy.new do |a, b| true end - retry_policy.should_retry?(nil, nil).must_equal true + _(retry_policy.should_retry?(nil, nil)).must_equal true end it "uses linear retry policy" do retry_count = retry_interval = 1 retry_policy = Azure::Storage::Common::Core::Filter::LinearRetryPolicyFilter.new retry_count, retry_interval - retry_policy.should_retry?(nil, error: "SocketError: Hostname not known").must_equal true + _(retry_policy.should_retry?(nil, error: "SocketError: Hostname not known")).must_equal true end it "uses exponential retry policy" do retry_count = retry_interval = 1 retry_policy = Azure::Storage::Common::Core::Filter::ExponentialRetryPolicyFilter.new retry_count, retry_interval - retry_policy.should_retry?(nil, error: "Errno::EPROTONOSUPPORT").must_equal false + _(retry_policy.should_retry?(nil, error: "Errno::EPROTONOSUPPORT")).must_equal false end describe "RetryPolicy retries with a new URL" do @@ -73,7 +73,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal secondary_uri + _(request.uri).must_equal secondary_uri end it "retries with a new URL: SECONDARY_THEN_PRIMARY" do @@ -86,7 +86,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal primary_uri + _(request.uri).must_equal primary_uri end it "retries with a new URL: PRIMARY_ONLY" do @@ -99,7 +99,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal primary_uri + _(request.uri).must_equal primary_uri end it "retries with a new URL: SECONDARY_ONLY" do @@ -112,7 +112,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal secondary_uri + _(request.uri).must_equal secondary_uri end it "retries with a new URL: PRIMARY_THEN_SECONDARY, API: PRIMARY_ONLY" do @@ -125,7 +125,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal primary_uri + _(request.uri).must_equal primary_uri end it "retries with a new URL: SECONDARY_THEN_PRIMARY, API: SECONDARY_ONLY" do @@ -138,7 +138,7 @@ describe Azure::Core::Http::RetryPolicy do } subject.retry_data = retry_data subject.call request, request - request.uri.must_equal secondary_uri + _(request.uri).must_equal secondary_uri end end end diff --git a/test/unit/core/http_client_test.rb b/test/unit/core/http_client_test.rb index 709fd49019aca8ca229cb58c23f720b17a6b5800..1133400de24172c3af08ec5797659f30175c1fad 100644 --- a/test/unit/core/http_client_test.rb +++ b/test/unit/core/http_client_test.rb @@ -24,11 +24,11 @@ describe Azure::Storage::Common::Core::HttpClient do describe "ssl vs non ssl uris" do it "should set verify true if using ssl" do - Azure::Storage::Common::Client::create.agents(uri).ssl[:verify].must_equal true + _(Azure::Storage::Common::Client::create.agents(uri).ssl[:verify]).must_equal true end it "should not set ssl if not using ssl" do - Azure::Storage::Common::Client::create.agents("http://localhost").ssl.must_be_empty + _(Azure::Storage::Common::Client::create.agents("http://localhost").ssl).must_be_empty end end @@ -44,7 +44,7 @@ describe Azure::Storage::Common::Core::HttpClient do end it "should set the proxy configuration information on the http connection" do - Azure::Storage::Common::Client::create.agents(uri).proxy.uri.must_equal http_proxy_uri + _(Azure::Storage::Common::Client::create.agents(uri).proxy.uri).must_equal http_proxy_uri end end @@ -60,7 +60,7 @@ describe Azure::Storage::Common::Core::HttpClient do end it "should set the proxy configuration information on the https connection" do - Azure::Storage::Common::Client::create.agents(uri).proxy.uri.must_equal https_proxy_uri + _(Azure::Storage::Common::Client::create.agents(uri).proxy.uri).must_equal https_proxy_uri end end end diff --git a/test/unit/file/file_service_test.rb b/test/unit/file/file_service_test.rb index bfa1b347269e6e193c292feb1cb1f6e7ee8c6b5e..0a21d22b491b847519f362dd8e22c4a2a44419d7 100644 --- a/test/unit/file/file_service_test.rb +++ b/test/unit/file/file_service_test.rb @@ -77,7 +77,7 @@ describe Azure::Storage::File::FileService do it "returns a list of containers for the account" do result = subject.list_shares - result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults + _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults end describe "when the options Hash is used" do @@ -169,8 +169,8 @@ describe Azure::Storage::File::FileService do it "returns a new share" do result = subject.create_share share_name - result.must_be_kind_of Azure::Storage::File::Share::Share - result.name.must_equal share_name + _(result).must_be_kind_of Azure::Storage::File::Share::Share + _(result.name).must_equal share_name end describe "when optional metadata parameter is used" do @@ -218,7 +218,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.delete_share share_name - result.must_equal nil + _(result).must_equal nil end end @@ -245,7 +245,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.set_share_properties share_name - result.must_equal nil + _(result).must_equal nil end describe "when the options Hash is used" do @@ -304,9 +304,9 @@ describe Azure::Storage::File::FileService do it "returns a share, with it's properties attribute populated" do result = subject.get_share_properties share_name - result.must_be_kind_of Azure::Storage::File::Share::Share - result.name.must_equal share_name - result.properties.must_equal share_properties + _(result).must_be_kind_of Azure::Storage::File::Share::Share + _(result.name).must_equal share_name + _(result.properties).must_equal share_properties end end @@ -344,9 +344,9 @@ describe Azure::Storage::File::FileService do it "returns a share, with it's metadata attribute populated" do result = subject.get_share_metadata share_name - result.must_be_kind_of Azure::Storage::File::Share::Share - result.name.must_equal share_name - result.metadata.must_equal share_metadata + _(result).must_be_kind_of Azure::Storage::File::Share::Share + _(result.name).must_equal share_name + _(result.metadata).must_equal share_metadata end end @@ -378,7 +378,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.set_share_metadata share_name, share_metadata - result.must_equal nil + _(result).must_equal nil end end @@ -420,11 +420,11 @@ describe Azure::Storage::File::FileService do it "returns a share and an ACL" do returned_share, returned_acl = subject.get_share_acl share_name - returned_share.must_be_kind_of Azure::Storage::File::Share::Share - returned_share.name.must_equal share_name + _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share + _(returned_share.name).must_equal share_name - returned_acl.must_be_kind_of Array - returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(returned_acl).must_be_kind_of Array + _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier end end @@ -458,10 +458,10 @@ describe Azure::Storage::File::FileService do it "returns a share and an ACL" do returned_share, returned_acl = subject.set_share_acl share_name - returned_share.must_be_kind_of Azure::Storage::File::Share::Share - returned_share.name.must_equal share_name + _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share + _(returned_share.name).must_equal share_name - returned_acl.must_be_kind_of Array + _(returned_acl).must_be_kind_of Array end describe "when the signed_identifiers parameter is set" do @@ -485,11 +485,11 @@ describe Azure::Storage::File::FileService do subject.stubs(:call).with(verb, uri, request_body, request_headers, options).returns(response) returned_share, returned_acl = subject.set_share_acl share_name, options - returned_share.must_be_kind_of Azure::Storage::File::Share::Share - returned_share.name.must_equal share_name + _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share + _(returned_share.name).must_equal share_name - returned_acl.must_be_kind_of Array - returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(returned_acl).must_be_kind_of Array + _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier end end end @@ -528,9 +528,9 @@ describe Azure::Storage::File::FileService do subject.expects(:share_uri).with(share_name, query, options).returns(uri) serialization.expects(:share_stats_from_xml).with(response_body).returns(share_stats) result = subject.get_share_stats share_name - result.must_be_kind_of Azure::Storage::File::Share::Share - result.name.must_equal share_name - result.usage.must_equal share_stats + _(result).must_be_kind_of Azure::Storage::File::Share::Share + _(result.name).must_equal share_name + _(result.usage).must_equal share_stats end end end @@ -570,7 +570,7 @@ describe Azure::Storage::File::FileService do it "returns a list of containers for the account" do subject.expects(:directory_uri).with(share_name, directory_path, query, options).returns(uri) result = subject.list_directories_and_files share_name, directory_path - result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults + _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults end describe "when the options Hash is used" do @@ -649,9 +649,9 @@ describe Azure::Storage::File::FileService do it "returns a share, with it's properties attribute populated" do result = subject.get_directory_properties share_name, directory_path - result.must_be_kind_of Azure::Storage::File::Directory::Directory - result.name.must_equal directory_path - result.properties.must_equal directory_properties + _(result).must_be_kind_of Azure::Storage::File::Directory::Directory + _(result.name).must_equal directory_path + _(result.properties).must_equal directory_properties end end @@ -688,9 +688,9 @@ describe Azure::Storage::File::FileService do it "returns a directory, with it's metadata attribute populated" do result = subject.get_directory_metadata share_name, directory_path - result.must_be_kind_of Azure::Storage::File::Directory::Directory - result.name.must_equal directory_path - result.metadata.must_equal directory_metadata + _(result).must_be_kind_of Azure::Storage::File::Directory::Directory + _(result.name).must_equal directory_path + _(result.metadata).must_equal directory_metadata end end @@ -722,7 +722,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.set_directory_metadata share_name, directory_path, directory_metadata - result.must_equal nil + _(result).must_equal nil end end end @@ -761,9 +761,9 @@ describe Azure::Storage::File::FileService do it "returns a Blob on success" do result = subject.create_file share_name, directory_path, file_name, file_length - result.must_be_kind_of Azure::Storage::File::File - result.must_equal file - result.name.must_equal file_name + _(result).must_be_kind_of Azure::Storage::File::File + _(result).must_equal file + _(result.name).must_equal file_name end describe "when the options Hash is used" do @@ -856,9 +856,9 @@ describe Azure::Storage::File::FileService do it "returns a Blob on success" do result = subject.put_file_range share_name, directory_path, file_name, start_range, end_range, content - result.must_be_kind_of Azure::Storage::File::File - result.must_equal file - result.name.must_equal file_name + _(result).must_be_kind_of Azure::Storage::File::File + _(result).must_equal file + _(result.name).must_equal file_name end end @@ -892,9 +892,9 @@ describe Azure::Storage::File::FileService do it "returns a Blob on success" do result = subject.clear_file_range share_name, directory_path, file_name, start_range, end_range - result.must_be_kind_of Azure::Storage::File::File - result.must_equal file - result.name.must_equal file_name + _(result).must_be_kind_of Azure::Storage::File::File + _(result).must_equal file + _(result.name).must_equal file_name end describe "when start_range is provided" do @@ -956,10 +956,10 @@ describe Azure::Storage::File::FileService do it "returns a list of ranges" do file, result = subject.list_file_ranges share_name, directory_path, file_name - result.must_be_kind_of Array - result.first.must_be_kind_of Array - result.first.first.must_be_kind_of Integer - result.first.first.next.must_be_kind_of Integer + _(result).must_be_kind_of Array + _(result.first).must_be_kind_of Array + _(result.first.first).must_be_kind_of Integer + _(result.first.first.next).must_be_kind_of Integer end describe "when start_range is provided" do @@ -1044,7 +1044,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.set_file_properties share_name, directory_path, file_name - result.must_equal nil + _(result).must_equal nil end describe "when the options Hash is used" do @@ -1131,9 +1131,9 @@ describe Azure::Storage::File::FileService do subject.expects(:file_uri).with(share_name, directory_path, file_name, query, options).returns(uri) result = subject.get_file_properties share_name, directory_path, file_name - result.must_be_kind_of Azure::Storage::File::File - result.must_equal file - result.name.must_equal file_name + _(result).must_be_kind_of Azure::Storage::File::File + _(result).must_equal file + _(result.name).must_equal file_name end end @@ -1161,7 +1161,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.set_file_metadata share_name, directory_path, file_name, file_metadata - result.must_equal nil + _(result).must_equal nil end end @@ -1193,9 +1193,9 @@ describe Azure::Storage::File::FileService do subject.expects(:file_uri).with(share_name, directory_path, file_name, query, options).returns(uri) result = subject.get_file_metadata share_name, directory_path, file_name - result.must_be_kind_of Azure::Storage::File::File - result.must_equal file - result.name.must_equal file_name + _(result).must_be_kind_of Azure::Storage::File::File + _(result).must_equal file + _(result.name).must_equal file_name end end @@ -1225,9 +1225,9 @@ describe Azure::Storage::File::FileService do it "returns the file and file contents on success" do returned_file, returned_file_contents = subject.get_file share_name, directory_path, file_name - returned_file.must_be_kind_of Azure::Storage::File::File - returned_file.must_equal file - returned_file_contents.must_equal response_body + _(returned_file).must_be_kind_of Azure::Storage::File::File + _(returned_file).must_equal file + _(returned_file_contents).must_equal response_body end describe "when start_range is provided" do @@ -1325,7 +1325,7 @@ describe Azure::Storage::File::FileService do it "returns nil on success" do result = subject.delete_file share_name, directory_path, file_name - result.must_equal nil + _(result).must_equal nil end end @@ -1372,8 +1372,8 @@ describe Azure::Storage::File::FileService do it "returns the copy id and copy status on success" do returned_copy_id, returned_copy_status = subject.copy_file share_name, directory_path, file_name, source_share_name, source_directory_path, source_file_name - returned_copy_id.must_equal copy_id - returned_copy_status.must_equal copy_status + _(returned_copy_id).must_equal copy_id + _(returned_copy_status).must_equal copy_status end describe "when the options Hash is used" do diff --git a/test/unit/service/serialization_test.rb b/test/unit/service/serialization_test.rb index 5a42905241bdd1c48d8ec86baf82f93e79580c12..9eae22f410d3058627786835e09fbb0a149be3ea 100644 --- a/test/unit/service/serialization_test.rb +++ b/test/unit/service/serialization_test.rb @@ -39,9 +39,9 @@ describe Azure::Storage::Common::Service::Serialization do it "returns an Array of SignedIdentifier instances" do results = subject.signed_identifiers_from_xml signed_identifiers_xml - results.must_be_kind_of Array - results[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier - results.count.must_equal 1 + _(results).must_be_kind_of Array + _(results[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(results.count).must_equal 1 end end @@ -63,7 +63,7 @@ describe Azure::Storage::Common::Service::Serialization do it "returns a XML graph of the provided values" do xml = subject.signed_identifiers_to_xml signed_identifiers - xml.must_equal signed_identifiers_xml + _(xml).must_equal signed_identifiers_xml end end @@ -78,13 +78,13 @@ describe Azure::Storage::Common::Service::Serialization do it "returns a SignedIdentifier instance" do identifier = subject.signed_identifier_from_xml signed_identifier_xml - identifier.must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier + _(identifier).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier end it "sets the properties of the SignedIdentifier" do identifier = subject.signed_identifier_from_xml signed_identifier_xml - identifier.wont_be_nil - identifier.id.must_equal "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI=" + _(identifier).wont_be_nil + _(identifier.id).must_equal "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI=" end end @@ -97,16 +97,16 @@ describe Azure::Storage::Common::Service::Serialization do it "returns a AccessPolicy instance" do access_policy = subject.access_policy_from_xml access_policy_xml - access_policy.must_be_kind_of Azure::Storage::Common::Service::AccessPolicy + _(access_policy).must_be_kind_of Azure::Storage::Common::Service::AccessPolicy end it "sets the properties of the AccessPolicy" do access_policy = subject.access_policy_from_xml access_policy_xml - access_policy.wont_be_nil - access_policy.start.must_equal "2009-09-28T08:49:37.0000000Z" - access_policy.expiry.must_equal "2009-09-29T08:49:37.0000000Z" - access_policy.permission.must_equal "rwd" + _(access_policy).wont_be_nil + _(access_policy.start).must_equal "2009-09-28T08:49:37.0000000Z" + _(access_policy.expiry).must_equal "2009-09-29T08:49:37.0000000Z" + _(access_policy.permission).must_equal "rwd" end end @@ -118,20 +118,20 @@ describe Azure::Storage::Common::Service::Serialization do it "parses the XML and populates the provided EnumerationResults instance" do result = subject.enumeration_results_from_xml enumeration_results_xml, enumeration_results - result.must_be :kind_of?, Azure::Storage::Common::Service::EnumerationResults - result.continuation_token.must_equal "video" + _(result).must_be :kind_of?, Azure::Storage::Common::Service::EnumerationResults + _(result.continuation_token).must_equal "video" end it "returns the same instance provided" do result = subject.enumeration_results_from_xml enumeration_results_xml, enumeration_results - result.must_equal enumeration_results + _(result).must_equal enumeration_results end end describe "when passed nil" do it "returns a new instance of EnumerationResults" do result = subject.enumeration_results_from_xml enumeration_results_xml, nil - result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults + _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults end end end @@ -141,27 +141,27 @@ describe Azure::Storage::Common::Service::Serialization do let(:metadata_xml_node) { Nokogiri.Slop(list_containers_xml).root.Containers.Container[1].Metadata } it "converts a Metadata XML element to a Hash" do - subject.metadata_from_xml(metadata_xml_node).must_be_kind_of Hash + _(subject.metadata_from_xml(metadata_xml_node)).must_be_kind_of Hash end it "uses the child element names as keys" do hash = subject.metadata_from_xml(metadata_xml_node) - hash.has_key?("mymetadata1").must_equal true - hash.has_key?("mymetadata2").must_equal true - hash.has_key?("x-ms-invalid-name").must_equal true + _(hash.has_key?("mymetadata1")).must_equal true + _(hash.has_key?("mymetadata2")).must_equal true + _(hash.has_key?("x-ms-invalid-name")).must_equal true end it "uses the child element text contents as values" do hash = subject.metadata_from_xml(metadata_xml_node) - hash["mymetadata1"].must_equal "first value" - hash["mymetadata2"].must_equal "second value" + _(hash["mymetadata1"]).must_equal "first value" + _(hash["mymetadata2"]).must_equal "second value" end describe "when it encounters more than one of the same element name" do it "returns and array of values for that key" do hash = subject.metadata_from_xml(metadata_xml_node) - hash["x-ms-invalid-name"].must_be_kind_of Array - hash["x-ms-invalid-name"].must_equal ["invalid-metadata-name", "invalid-metadata-name2"] + _(hash["x-ms-invalid-name"]).must_be_kind_of Array + _(hash["x-ms-invalid-name"]).must_equal ["invalid-metadata-name", "invalid-metadata-name2"] end end end @@ -172,19 +172,19 @@ describe Azure::Storage::Common::Service::Serialization do let(:metadata_headers) { headers.merge("x-ms-meta-MyMetadata1" => "first value", "x-ms-meta-MyMetadata2" => "second value") } it "returns a Hash" do - subject.metadata_from_headers(metadata_headers).must_be_kind_of Hash + _(subject.metadata_from_headers(metadata_headers)).must_be_kind_of Hash end it "extracts metadata from a Hash for keys that start with x-ms-meta-* and removes that prefix" do hash = subject.metadata_from_headers(metadata_headers) - hash.has_key?("MyMetadata1").must_equal true - hash.has_key?("MyMetadata2").must_equal true + _(hash.has_key?("MyMetadata1")).must_equal true + _(hash.has_key?("MyMetadata2")).must_equal true end it "sets the metadata values to the corresponding header values" do hash = subject.metadata_from_headers(metadata_headers) - hash["MyMetadata1"].must_equal "first value" - hash["MyMetadata2"].must_equal "second value" + _(hash["MyMetadata1"]).must_equal "first value" + _(hash["MyMetadata2"]).must_equal "second value" end end @@ -209,7 +209,7 @@ describe Azure::Storage::Common::Service::Serialization do builder = Nokogiri::XML::Builder.new do |xml| subject.retention_policy_to_xml retention_policy, xml end - builder.to_xml.must_equal retention_policy_xml + _(builder.to_xml).must_equal retention_policy_xml end end @@ -222,14 +222,14 @@ describe Azure::Storage::Common::Service::Serialization do it "returns an RetentionPolicy instance" do retention_policy = subject.retention_policy_from_xml retention_policy_xml - retention_policy.wont_be_nil - retention_policy.must_be_kind_of Azure::Storage::Common::Service::RetentionPolicy + _(retention_policy).wont_be_nil + _(retention_policy).must_be_kind_of Azure::Storage::Common::Service::RetentionPolicy end it "sets the properties of the RetentionPolicy instance" do retention_policy = subject.retention_policy_from_xml retention_policy_xml - retention_policy.enabled.must_equal true - retention_policy.days.must_equal 7 + _(retention_policy.enabled).must_equal true + _(retention_policy.days).must_equal 7 end end @@ -258,7 +258,7 @@ describe Azure::Storage::Common::Service::Serialization do builder = Nokogiri::XML::Builder.new do |xml| subject.hour_metrics_to_xml metrics, xml end - builder.to_xml.must_equal metrics_xml + _(builder.to_xml).must_equal metrics_xml end end @@ -276,16 +276,16 @@ describe Azure::Storage::Common::Service::Serialization do it "returns an Metrics instance" do metrics = subject.metrics_from_xml metrics_xml - metrics.wont_be_nil - metrics.must_be_kind_of Azure::Storage::Common::Service::Metrics + _(metrics).wont_be_nil + _(metrics).must_be_kind_of Azure::Storage::Common::Service::Metrics end it "sets the properties of the Metrics instance" do metrics = subject.metrics_from_xml metrics_xml - metrics.version.must_equal "1.0" - metrics.enabled.must_equal true - metrics.include_apis.must_equal false - metrics.retention_policy.must_equal mock_retention_policy + _(metrics.version).must_equal "1.0" + _(metrics.enabled).must_equal true + _(metrics.include_apis).must_equal false + _(metrics.retention_policy).must_equal mock_retention_policy end end @@ -317,7 +317,7 @@ describe Azure::Storage::Common::Service::Serialization do builder = Nokogiri::XML::Builder.new do |xml| subject.logging_to_xml logging, xml end - builder.to_xml.must_equal logging_xml + _(builder.to_xml).must_equal logging_xml end end @@ -335,17 +335,17 @@ describe Azure::Storage::Common::Service::Serialization do it "returns an Logging instance" do logging = subject.logging_from_xml logging_xml - logging.wont_be_nil - logging.must_be_kind_of Azure::Storage::Common::Service::Logging + _(logging).wont_be_nil + _(logging).must_be_kind_of Azure::Storage::Common::Service::Logging end it "sets the properties of the Logging instance" do logging = subject.logging_from_xml logging_xml - logging.version.must_equal "1.0" - logging.delete.must_equal true - logging.read.must_equal false - logging.write.must_equal true - logging.retention_policy.must_equal mock_retention_policy + _(logging.version).must_equal "1.0" + _(logging.delete).must_equal true + _(logging.read).must_equal false + _(logging.write).must_equal true + _(logging.retention_policy).must_equal mock_retention_policy end end @@ -410,7 +410,7 @@ describe Azure::Storage::Common::Service::Serialization do it "returns a XML graph of the provided values" do xml = subject.service_properties_to_xml service_properties - xml.must_equal service_properties_xml + _(xml).must_equal service_properties_xml end end @@ -432,35 +432,35 @@ describe Azure::Storage::Common::Service::Serialization do it "returns an StorageServiceProperties instance" do service_properties = subject.service_properties_from_xml service_properties_xml - service_properties.wont_be_nil - service_properties.must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties + _(service_properties).wont_be_nil + _(service_properties).must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties end it "sets the properties of the StorageServiceProperties instance" do service_properties = subject.service_properties_from_xml service_properties_xml - service_properties.logging.must_equal mock_logging - service_properties.hour_metrics.must_equal mock_metrics - service_properties.minute_metrics.must_equal mock_metrics + _(service_properties.logging).must_equal mock_logging + _(service_properties.hour_metrics).must_equal mock_metrics + _(service_properties.minute_metrics).must_equal mock_metrics end end describe "#to_bool" do it "converts a valid string value to a Boolean" do - subject.to_bool("true").must_be_kind_of TrueClass - subject.to_bool("false").must_be_kind_of FalseClass + _(subject.to_bool("true")).must_be_kind_of TrueClass + _(subject.to_bool("false")).must_be_kind_of FalseClass end it "is case insensitive" do # mixed case - subject.to_bool("True").must_equal true + _(subject.to_bool("True")).must_equal true # upper case - subject.to_bool("TRUE").must_equal true + _(subject.to_bool("TRUE")).must_equal true end it "returns false for any value other than 'true'" do - subject.to_bool("random string").must_equal false - subject.to_bool(nil).must_equal false + _(subject.to_bool("random string")).must_equal false + _(subject.to_bool(nil)).must_equal false end end @@ -474,49 +474,49 @@ describe Azure::Storage::Common::Service::Serialization do it "parses the string into a Nokogiri::XML::Element node" do result = subject.slopify(xml_data) - result.must_be_kind_of Nokogiri::XML::Element + _(result).must_be_kind_of Nokogiri::XML::Element end it "returns the root of the parsed Document" do result = subject.slopify(xml_data) - result.name.must_equal root_node.name + _(result.name).must_equal root_node.name end it "enables Nokogiri 'Slop' mode on the returned Element" do result = subject.slopify(xml_data) - result.must_respond_to :method_missing + _(result).must_respond_to :method_missing end end describe "when passed a Nokogiri::XML::Document" do it "returns a Nokogiri::XML::Element node" do result = subject.slopify(document) - result.must_be_kind_of Nokogiri::XML::Element + _(result).must_be_kind_of Nokogiri::XML::Element end it "returns the root of the Document" do result = subject.slopify(document) - result.name.must_equal root_node.name + _(result.name).must_equal root_node.name end it "enables Nokogiri 'Slop' mode on the returned Element" do result = subject.slopify(xml_data) - result.must_respond_to :method_missing + _(result).must_respond_to :method_missing end end describe "when passed a Nokogiri::XML::Element" do it "returns the Element unchanged" do result = subject.slopify(root_node) - result.must_equal root_node + _(result).must_equal root_node end it "does not enable Nokogiri 'Slop' mode on the returned Element if it didn't already have it" do result = subject.slopify(root_node) - result.respond_to?(:method_missing).must_equal root_node.respond_to?(:method_missing) + _(result.respond_to?(:method_missing)).must_equal root_node.respond_to?(:method_missing) result = subject.slopify(non_slop_node) - result.respond_to?(:method_missing).must_equal non_slop_node.respond_to?(:method_missing) + _(result.respond_to?(:method_missing)).must_equal non_slop_node.respond_to?(:method_missing) end end end diff --git a/test/unit/service/storage_service_test.rb b/test/unit/service/storage_service_test.rb index 4991826b80fce0ff2fd5785913550d9903eadeab..d51c3a8ef719ab3a1798a46f456955e24a101323 100644 --- a/test/unit/service/storage_service_test.rb +++ b/test/unit/service/storage_service_test.rb @@ -120,19 +120,19 @@ describe Azure::Storage::Common::Service::StorageService do initial_length = subject.filters.length filter = mock() subject.with_filter filter - subject.filters.length.must_equal initial_length + 1 + _(subject.filters.length).must_equal initial_length + 1 end it "accepts object instances as filters" do filter = mock() subject.with_filter filter - subject.filters.last.must_equal filter + _(subject.filters.last).must_equal filter end it "accepts blocks as filters" do subject.with_filter do |a, b| end - subject.filters.last.class.must_equal Proc + _(subject.filters.last.class).must_equal Proc end it "preserves the order of the filters" do @@ -146,9 +146,9 @@ describe Azure::Storage::Common::Service::StorageService do subject.with_filter do |a, b| end - subject.filters.first.must_equal filter - subject.filters[1].must_equal filter1 - subject.filters.last.class.must_equal Proc + _(subject.filters.first).must_equal filter + _(subject.filters[1]).must_equal filter1 + _(subject.filters.last.class).must_equal Proc end end @@ -196,7 +196,7 @@ describe Azure::Storage::Common::Service::StorageService do it "returns a StorageServiceProperties instance" do result = subject.get_service_properties - result.must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties + _(result).must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties end end @@ -250,17 +250,17 @@ describe Azure::Storage::Common::Service::StorageService do describe "service_properties_uri" do it "returns an instance of URI" do - subject.service_properties_uri.must_be_kind_of URI + _(subject.service_properties_uri).must_be_kind_of URI end it "uses the value of the host property as the base of the url" do - subject.service_properties_uri.to_s.must_include subject.host + _(subject.service_properties_uri.to_s).must_include subject.host subject.host = "http://something.else" - subject.service_properties_uri.to_s.must_include subject.host + _(subject.service_properties_uri.to_s).must_include subject.host end it "sets a query string that specifies the storage service properties endpoint" do - subject.service_properties_uri.query.must_include "restype=service&comp=properties" + _(subject.service_properties_uri.query).must_include "restype=service&comp=properties" end end @@ -314,23 +314,23 @@ describe Azure::Storage::Common::Service::StorageService do it "returns a StorageServiceStats instance" do result = subject.get_service_stats - result.must_be_kind_of Azure::Storage::Common::Service::StorageServiceStats + _(result).must_be_kind_of Azure::Storage::Common::Service::StorageServiceStats end end describe "service_stats_uri" do it "returns an instance of URI" do - subject.service_stats_uri.must_be_kind_of URI + _(subject.service_stats_uri).must_be_kind_of URI end it "uses the value of the host property as the base of the url" do - subject.service_stats_uri.to_s.must_include subject.host + _(subject.service_stats_uri.to_s).must_include subject.host subject.host = "http://something.else" - subject.service_stats_uri.to_s.must_include subject.host + _(subject.service_stats_uri.to_s).must_include subject.host end it "sets a query string that specifies the storage service stats endpoint" do - subject.service_stats_uri.query.must_include "restype=service&comp=stats" + _(subject.service_stats_uri.query).must_include "restype=service&comp=stats" end end @@ -338,55 +338,55 @@ describe Azure::Storage::Common::Service::StorageService do it "prefixes header names with x-ms-meta- but does not modify the values" do headers = {} Azure::Storage::Common::Service::StorageService.add_metadata_to_headers({ "Foo" => "Bar" }, headers) - headers.keys.must_include "x-ms-meta-Foo" - headers["x-ms-meta-Foo"].must_equal "Bar" + _(headers.keys).must_include "x-ms-meta-Foo" + _(headers["x-ms-meta-Foo"]).must_equal "Bar" end it "updates any existing x-ms-meta-* headers with the new values" do headers = { "x-ms-meta-Foo" => "Foo" } Azure::Storage::Common::Service::StorageService.add_metadata_to_headers({ "Foo" => "Bar" }, headers) - headers["x-ms-meta-Foo"].must_equal "Bar" + _(headers["x-ms-meta-Foo"]).must_equal "Bar" end end describe "#generate_uri" do it "returns a URI instance" do - subject.generate_uri.must_be_kind_of ::URI + _(subject.generate_uri).must_be_kind_of ::URI end describe "when called with no arguments" do it "returns the StorageService host URL" do - subject.generate_uri.to_s.must_equal "http://dumyhost.uri/" + _(subject.generate_uri.to_s).must_equal "http://dumyhost.uri/" end end describe "when passed an optional path" do it "adds the path to the host url" do - subject.generate_uri("resource/entity/").path.must_equal "/resource/entity/" + _(subject.generate_uri("resource/entity/").path).must_equal "/resource/entity/" end it "correctly joins the path if the host url contained a path" do subject.storage_service_host[:primary] = "http://dummy.uri/host/path" - subject.generate_uri("resource/entity/").path.must_equal "/host/path/resource/entity/" + _(subject.generate_uri("resource/entity/").path).must_equal "/host/path/resource/entity/" end end describe "when passed an Hash of query parameters" do it "encodes the keys" do - subject.generate_uri("", "key !" => "value").query.must_include "key+%21=value" + _(subject.generate_uri("", "key !" => "value").query).must_include "key+%21=value" end it "encodes the values" do - subject.generate_uri("", "key" => "value !").query.must_include "key=value+%21" + _(subject.generate_uri("", "key" => "value !").query).must_include "key=value+%21" end it "sets the query string to the encoded result" do - subject.generate_uri("", "key" => "value !", "key !" => "value").query.must_equal "key=value+%21&key+%21=value" + _(subject.generate_uri("", "key" => "value !", "key !" => "value").query).must_equal "key=value+%21&key+%21=value" end describe "when the query parameters include a timeout key" do it "overrides the default timeout" do - subject.generate_uri("", "timeout" => 45).query.must_equal "timeout=45" + _(subject.generate_uri("", "timeout" => 45).query).must_equal "timeout=45" end end @@ -399,17 +399,17 @@ describe Azure::Storage::Common::Service::StorageService do describe "when passed an optional location" do it "default location should be primary" do - subject.generate_uri("", nil).to_s.must_equal "http://dumyhost.uri/" + _(subject.generate_uri("", nil).to_s).must_equal "http://dumyhost.uri/" end it "primary location should work" do - subject.generate_uri("", nil, { location_mode: Azure::Storage::Common::LocationMode::PRIMARY_ONLY}).to_s.must_equal "http://dumyhost.uri/" + _(subject.generate_uri("", nil, { location_mode: Azure::Storage::Common::LocationMode::PRIMARY_ONLY}).to_s).must_equal "http://dumyhost.uri/" end it "secondary location should work" do - subject.generate_uri("", nil, + _(subject.generate_uri("", nil, { location_mode: Azure::Storage::Common::LocationMode::SECONDARY_ONLY, - request_location_mode: Azure::Storage::Common::RequestLocationMode::PRIMARY_OR_SECONDARY}).to_s.must_equal "http://dumyhost-secondary.uri/" + request_location_mode: Azure::Storage::Common::RequestLocationMode::PRIMARY_OR_SECONDARY}).to_s).must_equal "http://dumyhost-secondary.uri/" end it "raise exception when primary only" do diff --git a/test/unit/table/edmtype_test.rb b/test/unit/table/edmtype_test.rb index 1ad369212496a3d7c5b1eff9c85e9423246ca792..e545bd132f5b98fd02d52f97598e5ff4997ba280 100644 --- a/test/unit/table/edmtype_test.rb +++ b/test/unit/table/edmtype_test.rb @@ -29,43 +29,43 @@ describe Azure::Storage::Table::EdmType do it "correctly serializes int64 query values" do value = 2**128 + 1256231 serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal value.to_s + "L" + _(serializedValue).must_equal value.to_s + "L" end it "correctly serializes int32 query values" do value = 2 serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "2" + _(serializedValue).must_equal "2" end it "correctly serializes datetime query values" do value = DateTime.new(2001, 2, 3, 4, 5, 6) serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "datetime'2001-02-03T04:05:06+00:00'" + _(serializedValue).must_equal "datetime'2001-02-03T04:05:06+00:00'" end it "correctly serializes guid query values" do value = Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921") serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "guid'81425519-6394-43e4-ac6e-28d91f5c3921'" + _(serializedValue).must_equal "guid'81425519-6394-43e4-ac6e-28d91f5c3921'" end it "correctly serializes float query values" do value = 1.2 serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "1.2" + _(serializedValue).must_equal "1.2" end it "correctly serializes string query values" do value = "string" serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "string" + _(serializedValue).must_equal "string" end it "correctly serializes binary query values" do value = "1".force_encoding("BINARY") serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value) - serializedValue.must_equal "X'31'" + _(serializedValue).must_equal "X'31'" end end @@ -73,43 +73,43 @@ describe Azure::Storage::Table::EdmType do it "correctly deserializes int64 query values" do value = "340282366920938463463374607431769467687" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Int64") - deserializedValue.must_equal (2**128 + 1256231) + _(deserializedValue).must_equal (2**128 + 1256231) end it "correctly deserializes int32 query values" do value = "2" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Int32") - deserializedValue.must_equal 2 + _(deserializedValue).must_equal 2 end it "correctly deserializes datetime query values" do value = "2001-02-03T04:05:06+00:00" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.DateTime") - deserializedValue.must_equal Time.new(2001, 2, 3, 4, 5, 6, "+00:00") + _(deserializedValue).must_equal Time.new(2001, 2, 3, 4, 5, 6, "+00:00") end it "correctly deserializes guid query values" do value = "81425519-6394-43e4-ac6e-28d91f5c3921" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Guid") - deserializedValue.must_equal Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921") + _(deserializedValue).must_equal Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921") end it "correctly deserializes float query values" do value = "1.2" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Double") - deserializedValue.must_equal 1.2 + _(deserializedValue).must_equal 1.2 end it "correctly deserializes string query values" do value = "string" deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.String") - deserializedValue.must_equal "string" + _(deserializedValue).must_equal "string" end it "correctly deserializes binary query values" do value = "MTIzNDU=".force_encoding("BINARY") deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Binary") - deserializedValue.must_equal "12345" + _(deserializedValue).must_equal "12345" end end end diff --git a/test/unit/table/serialization_test.rb b/test/unit/table/serialization_test.rb index 2138f649127e8c55e15fbf45d2a211b228c86e80..cdaa404e157f6b4d2cd21ea6a1e3f5db436cd7d8 100644 --- a/test/unit/table/serialization_test.rb +++ b/test/unit/table/serialization_test.rb @@ -46,7 +46,7 @@ describe Azure::Storage::Table::Serialization do } it "serialize a hash to JSON string" do result = subject.hash_to_json(query_entities_response_hash) - result.must_equal query_entities_response_json + _(result).must_equal query_entities_response_json end end @@ -74,7 +74,7 @@ describe Azure::Storage::Table::Serialization do it "deserialize a table entries from json" do result = subject.table_entries_from_json(query_tables_json) - result.must_equal table_entries + _(result).must_equal table_entries end end @@ -83,9 +83,9 @@ describe Azure::Storage::Table::Serialization do it "create an entity from JSON" do result = subject.entity_from_json(entity_json) - result.must_be_kind_of Azure::Storage::Table::Entity - result.etag.must_equal "sampleetag" - result.properties.must_equal("PartitionKey" => "abcd321", "RowKey" => "abcd123" , "CustomDoubleProperty" => "3.141592") + _(result).must_be_kind_of Azure::Storage::Table::Entity + _(result.etag).must_equal "sampleetag" + _(result.properties).must_equal("PartitionKey" => "abcd321", "RowKey" => "abcd123" , "CustomDoubleProperty" => "3.141592") end end @@ -95,13 +95,13 @@ describe Azure::Storage::Table::Serialization do it "create entities array from JSON string" do result = subject.entities_from_json(multiple_entities_json) result.each do |e| - e.properties["PartitionKey"].must_include "part" - e.properties["RowKey"].must_include "entity-" - e.properties["Timestamp"].must_include "2017-09-12" - e.properties["CustomStringProperty"].must_equal "CustomPropertyValue" - e.properties["CustomIntegerProperty"].must_equal 37 - e.properties["CustomBooleanProperty"].must_equal true - e.properties["CustomDateProperty"].to_i.must_equal Time.parse("2017-09-12 03:40:23 UTC").to_i + _(e.properties["PartitionKey"]).must_include "part" + _(e.properties["RowKey"]).must_include "entity-" + _(e.properties["Timestamp"]).must_include "2017-09-12" + _(e.properties["CustomStringProperty"]).must_equal "CustomPropertyValue" + _(e.properties["CustomIntegerProperty"]).must_equal 37 + _(e.properties["CustomBooleanProperty"]).must_equal true + _(e.properties["CustomDateProperty"].to_i).must_equal Time.parse("2017-09-12 03:40:23 UTC").to_i end end end @@ -121,7 +121,7 @@ describe Azure::Storage::Table::Serialization do it "create accept string with input" do expected_results.each do |k, v| - subject.get_accept_string(k).must_equal v + _(subject.get_accept_string(k)).must_equal v end end end