clientside_aws 0.0.17

data/spec/ec2_spec.rb

@@ -0,0 +1,138 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../"
+
+require 'spec/spec_helper'
+
+describe 'EC2 Spec' do
+  include Rack::Test::Methods
+  def app
+    Sinatra::Application
+  end
+
+  def build_ec2_args(security_group:, remote_addr:, mask:, port:)
+    args = { group_id: security_group }
+    if remote_addr =~ /\:/ && remote_addr.length >= 16
+      args[:ip_permissions] = [{
+        from_port: port,
+        to_port: port,
+        ip_protocol: 'tcp',
+        ipv_6_ranges: [{ cidr_ipv_6: "#{remote_addr}/#{mask}" }]
+      }]
+    else
+      args[:ip_permissions] = [{
+        from_port: port,
+        to_port: port,
+        ip_protocol: 'tcp',
+        ip_ranges: [{ cidr_ip: "#{remote_addr}/#{mask}" }]
+      }]
+    end
+
+    args
+  end
+
+  it 'should create ingress groups' do
+    ec2 = Aws::EC2::Client.new
+
+    args = build_ec2_args(
+      security_group: 'sg-foo',
+      remote_addr: '192.168.99.100',
+      mask: 24,
+      port: 443
+    )
+    ec2.authorize_security_group_ingress(args)
+
+    desc = ec2.describe_security_groups(
+      group_ids: ['sg-foo']
+    )
+    expect(desc.security_groups.length).to eq 1
+    count_of_ip_ranges = \
+      desc&.security_groups&.first&.ip_permissions&.first&.ip_ranges&.length
+    expect(count_of_ip_ranges).to eq 1
+
+    first_ip_range = \
+      desc&.security_groups&.first&.ip_permissions&.first&.ip_ranges&.first
+    expect(first_ip_range.cidr_ip).to eq '192.168.99.0/24'
+
+    args = build_ec2_args(
+      security_group: 'sg-foo',
+      remote_addr: '192.168.99.0',
+      mask: 24,
+      port: 443
+    )
+
+    ec2.revoke_security_group_ingress(args)
+
+    desc = ec2.describe_security_groups(
+      group_ids: ['sg-foo']
+    )
+
+    expect(desc.security_groups.first.ip_permissions.first).to be nil
+  end
+
+  it 'should create ingress groups on different ports' do
+    ec2 = Aws::EC2::Client.new
+
+    args = build_ec2_args(
+      security_group: 'sg-foo2',
+      remote_addr: '192.168.99.101',
+      mask: 16,
+      port: 22
+    )
+
+    ec2.authorize_security_group_ingress(args)
+
+    args = build_ec2_args(
+      security_group: 'sg-foo2',
+      remote_addr: '10.0.0.1',
+      mask: 32,
+      port: 22
+    )
+
+    ec2.authorize_security_group_ingress(args)
+
+    desc = ec2.describe_security_groups(
+      group_ids: ['sg-foo2']
+    )
+
+    ip_ranges = \
+      desc.security_groups.first.ip_permissions.first.ip_ranges.map(&:cidr_ip)
+
+    expect(ip_ranges.include?('10.0.0.1/32')).to be true
+    expect(ip_ranges.include?('192.168.0.0/16')).to be true
+
+    args = build_ec2_args(
+      security_group: 'sg-foo2',
+      remote_addr: '10.0.0.1',
+      mask: 32,
+      port: 22
+    )
+
+    ec2.revoke_security_group_ingress(args)
+
+    desc = ec2.describe_security_groups(
+      group_ids: ['sg-foo2']
+    )
+
+    ip_ranges = \
+      desc.security_groups.first.ip_permissions.first.ip_ranges.map(&:cidr_ip)
+
+    expect(ip_ranges.include?('10.0.0.1/32')).to be false
+    expect(ip_ranges.include?('192.168.0.0/16')).to be true
+
+    args = build_ec2_args(
+      security_group: 'sg-foo2',
+      remote_addr: '192.168.0.0',
+      mask: 16,
+      port: 22
+    )
+
+    ec2.revoke_security_group_ingress(args)
+
+    desc = ec2.describe_security_groups(
+      group_ids: ['sg-foo2']
+    )
+
+    ip_ranges = \
+      desc.security_groups.first.ip_permissions
+    expect(ip_ranges.length.zero?).to be true
+  end
+end

data/spec/firehose_spec.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../"
+
+require 'spec/spec_helper'
+
+describe 'Profiles Spec' do
+  include Rack::Test::Methods
+  def app
+    Sinatra::Application
+  end
+
+  it 'should post to Firehose okay' do
+    firehose = Aws::Firehose::Client.new
+    firehose.put_record_batch(delivery_stream_name: 'test',
+                              records: [{ data: 'foo' }, { data: 'bar' }])
+  end
+end

data/spec/kinesis_spec.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../"
+
+require 'spec/spec_helper'
+
+describe 'Profiles Spec' do
+  include Rack::Test::Methods
+  def app
+    Sinatra::Application
+  end
+
+  it 'v1: should post to Kinesis okay' do
+    AWS::Kinesis::Client.new.put_record(stream_name: 'foo',
+                                        data: { bar: 1 }.to_json,
+                                        partition_key: 1.to_s)
+  end
+
+  it 'v2: should post to Kinesis okay' do
+    Aws::Kinesis::Client.new.put_record(stream_name: 'foo',
+                                        data: { bar: 1 }.to_json,
+                                        partition_key: 1.to_s)
+  end
+end

data/spec/s3_spec.rb

@@ -0,0 +1,219 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../"
+
+require 'spec/spec_helper'
+
+describe 'Profiles Spec' do
+  include Rack::Test::Methods
+  def app
+    Sinatra::Application
+  end
+  # adding in for ability to access via other 'examples'
+
+  it 'says hello' do
+    get '/'
+    expect(last_response.ok?).to be true
+  end
+
+  it 'v1: should post to S3 okay' do
+    s3 = AWS::S3.new
+    s3.buckets.create('test')
+    bucket = s3.buckets['test']
+    expect(bucket.exists?).to be true
+    object = bucket.objects['test.file']
+
+    initial_hash = \
+      Digest::MD5.hexdigest(File.read("#{File.dirname(__FILE__)}" \
+                                      '/../public/images/spacer.gif'))
+
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+    expect(Digest::MD5.hexdigest(object.read)).to eq initial_hash
+    expect(object.exists?).to be true
+
+    expect(bucket.objects['asdfdsfasdf'].exists?).to be false
+
+    object.delete
+    expect(object.exists?).to be false
+
+    json_value = { foo: 'bar' }.to_json
+    object = bucket.objects['test.json']
+    object.write(json_value, content_type: 'application/json')
+    expect(object.read).to eq json_value
+    expect(object.content_type).to eq 'application/json'
+    expect(object.etag).to eq Digest::MD5.hexdigest(json_value)
+  end
+
+  it 'v2: should post to S3 okay' do
+    s3 = Aws::S3::Client.new
+    s3.create_bucket(bucket: 'test')
+
+    bucket = Aws::S3::Resource.new.bucket('test')
+    expect(bucket.exists?).to be true
+
+    s3.put_object(bucket: 'test',
+                  key: 'test.file',
+                  body: File.new("#{File.dirname(__FILE__)}" \
+                        '/../public/images/spacer.gif'))
+    initial_hash = \
+      Digest::MD5.hexdigest(File.read("#{File.dirname(__FILE__)}" \
+                                      '/../public/images/spacer.gif'))
+
+    bucket = Aws::S3::Resource.new.bucket('test')
+    object = bucket.object('test.file')
+    expect(Digest::MD5.hexdigest(object.get.body.read)).to eq initial_hash
+
+    expect(object.exists?).to be true
+
+    # expect(bucket.objects['asdfdsfasdf'].exists?).to be false
+
+    object.delete
+    object = bucket.object('test.file')
+
+    expect(object.exists?).to be false
+  end
+
+  it 'v2: stores JSON document' do
+    s3 = Aws::S3::Client.new
+    s3.create_bucket(bucket: 'test')
+
+    bucket = Aws::S3::Resource.new.bucket('test')
+    expect(bucket.exists?).to be true
+
+    # Now, store a JSON document
+    json_value = { foo: 'bar' }.to_json
+    object = bucket.object('test.json')
+    object.put(body: json_value, content_type: 'application/json')
+
+    object = bucket.object('test.json')
+    expect(object.get.body.read).to eq json_value
+    expect(object.content_type).to eq 'application/json'
+    expect(object.etag).to eq Digest::MD5.hexdigest(json_value)
+  end
+
+  it 'v1: should support subpaths' do
+    s3 = AWS::S3.new
+    s3.buckets.create('test')
+    bucket = s3.buckets[:test]
+    expect(bucket.exists?).to be true
+    object = bucket.objects['foo/bar/test.file']
+
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+    expect(object.exists?).to be true
+
+    s3_object = object.read
+    expect(s3_object.length).to eq 43
+  end
+
+  it 'v2: should support subpaths' do
+    s3 = Aws::S3::Client.new
+
+    s3.create_bucket(bucket: 'test')
+    bucket = Aws::S3::Resource.new.bucket('test')
+    expect(bucket.exists?).to be true
+    object = bucket.object('foo/bar/test.file')
+
+    object.put(body: File.new("#{File.dirname(__FILE__)}" \
+                              '/../public/images/spacer.gif'))
+    expect(object.exists?).to be true
+
+    gif_content = object.get.body.read
+    expect(gif_content.length).to eq 43
+  end
+
+  it 'v1: should support rename_to' do
+    s3 = AWS::S3.new
+    s3.buckets.create('test1')
+    bucket = s3.buckets[:test]
+    expect(bucket.exists?).to be true
+    object = bucket.objects['test1_v1.file']
+
+    initial_hash = Digest::MD5.hexdigest(File.read("#{File.dirname(__FILE__)}/../public/images/spacer.gif"))
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+    expect(Digest::MD5.hexdigest(object.read)).to eq initial_hash
+    expect(object.exists?).to be true
+
+    object.rename_to('test2_v1.file')
+
+    renamed_object = bucket.objects['test2_v1.file']
+    expect(renamed_object.exists?).to be true
+    expect(renamed_object.read.nil?).to be false
+  end
+
+  it 'v2: should support rename_to' do
+    s3 = Aws::S3::Client.new
+
+    s3.create_bucket(bucket: 'test')
+    bucket = Aws::S3::Resource.new.bucket('test')
+    expect(bucket.exists?).to be true
+
+    object = bucket.object('test_v2.file')
+    object.put(body: File.new("#{File.dirname(__FILE__)}" \
+                              '/../public/images/spacer.gif'))
+
+    object2 = bucket.object('test2_v2.file')
+    expect(object2.exists?).to be false
+    object.move_to(object2)
+    expect(object2.exists?).to be true
+    expect(object.exists?).to be false
+  end
+
+  it 'v1: should list' do
+    s3 = AWS::S3.new
+    bucket_name = SecureRandom.hex(10)
+    s3.buckets.create(bucket_name)
+    bucket = s3.buckets[bucket_name]
+    expect(bucket.exists?).to be true
+    object = bucket.objects['test.file']
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+
+    expect(bucket.objects.count).to eq 1
+  end
+
+  it 'v2: should list' do
+    s3 = Aws::S3::Client.new
+
+    bucket_name = SecureRandom.hex(10)
+    s3.create_bucket(bucket: bucket_name)
+    bucket = Aws::S3::Resource.new.bucket(bucket_name)
+    expect(bucket.exists?).to be true
+
+    object = bucket.object('test.file')
+    object.put(body: File.new("#{File.dirname(__FILE__)}" \
+                              '/../public/images/spacer.gif'))
+
+    expect(bucket.objects.count).to eq 1
+  end
+
+  it 'v1: should respect prefix' do
+    s3 = AWS::S3.new
+    bucket_name = SecureRandom.hex(10)
+    s3.buckets.create(bucket_name)
+    bucket = s3.buckets[bucket_name]
+    expect(bucket.exists?).to be true
+    object = bucket.objects['apple.gif']
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+
+    object = bucket.objects['banana.gif']
+    object.write(file: "#{File.dirname(__FILE__)}/../public/images/spacer.gif")
+
+    expect(bucket.objects.with_prefix('apple').count).to eq 1
+  end
+
+  it 'v2: should respect prefix' do
+    s3 = Aws::S3::Client.new
+
+    bucket_name = SecureRandom.hex(10)
+    s3.create_bucket(bucket: bucket_name)
+    bucket = Aws::S3::Resource.new.bucket(bucket_name)
+    expect(bucket.exists?).to be true
+
+    object = bucket.object('apple.gif')
+    object.put(body: File.new("#{File.dirname(__FILE__)}" \
+                              '/../public/images/spacer.gif'))
+
+    object = bucket.object('banana.gif')
+    object.put(body: File.new("#{File.dirname(__FILE__)}" \
+                              '/../public/images/spacer.gif'))
+
+    expect(bucket.objects(prefix: 'apple').count).to eq 1
+  end
+end

data/spec/sns_spec.rb

@@ -0,0 +1,72 @@
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../"
+
+require 'spec/spec_helper'
+
+describe 'Profiles Spec' do
+  include Rack::Test::Methods
+  def app
+    Sinatra::Application
+  end
+  # adding in for ability to access via other 'examples'
+
+  it 'says hello' do
+    get '/'
+    expect(last_response).to be_ok
+  end
+
+  it 'v1: should post to SNS okay' do
+    sns = AWS::SNS.new
+
+    response = sns.client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/APNS/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/APNS}).not_to be nil
+
+    response = sns.client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/WNS/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/WNS}).not_to be nil
+
+    response = sns.client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/GCM/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/GCM}).not_to be nil
+  end
+
+  it 'v2: should post to SNS okay' do
+    sns_client = Aws::SNS::Client.new
+
+    response = sns_client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/APNS/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/APNS}).not_to be nil
+
+    response = sns_client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/WNS/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/WNS}).not_to be nil
+
+    response = sns_client.create_platform_endpoint(
+      platform_application_arn: \
+        'arn:aws:sns:us-east-1:999999999999:app/GCM/MYAPP',
+      token: 'token'
+    )
+    expect(response.data[:endpoint_arn]).not_to be_nil
+    expect(response.data[:endpoint_arn] =~ %r{endpoint/GCM}).not_to be nil
+  end
+end