geoengineer 0.1.0

data/spec/resources/aws_iam_user.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsIamUser") do
+  common_resource_tests(GeoEngineer::Resources::AwsIamUser,
+                        'aws_iam_user')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      iam = AwsClients.iam
+      # iam.list_policies.policies
+      stub = iam.stub_data(
+        :list_users,
+        {
+          users: [
+            {
+              user_name: 'FakeUser',
+              user_id: 'ANTIPASTAAC2ZFSLA',
+              arn: 'arn:aws:iam::123456789012:user/FakeUser',
+              path: '/'
+            },
+            {
+              user_name: 'FakeUser',
+              user_id: 'ANTIPASTAAC2ZFSLA',
+              arn: 'arn:aws:iam::123456789012:user/FakeUser',
+              path: '/'
+            }
+          ]
+        }
+      )
+      sns.stub_responses(:list_users, stub)
+      remote_resources = GeoEngineer::Resources::AwsIamUser._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_instance_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsInstance") do
+  common_resource_tests(GeoEngineer::Resources::AwsInstance, 'aws_instance')
+  name_tag_geo_id_tests(GeoEngineer::Resources::AwsInstance)
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      ec2 = AwsClients.ec2
+      stub = ec2.stub_data(
+        :describe_instances,
+        {
+          reservations: [
+            instances: [
+              { instance_id: 'name1', tags: [{ key: 'Name', value: 'one' }] },
+              { instance_id: 'name2', tags: [{ key: 'Name', value: 'two' }] }
+            ]
+          ]
+        }
+      )
+      ec2.stub_responses(:describe_instances, stub)
+      remote_resources = GeoEngineer::Resources::AwsInstance._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_proxy_protocol_policy_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsProxyProtocolPolicy") do
+  common_resource_tests(GeoEngineer::Resources::AwsProxyProtocolPolicy, 'aws_proxy_protocol_policy')
+end

data/spec/resources/aws_redshift_cluster_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsRedshiftCluster") do
+  let(:aws_client) { AwsClients.redshift }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsRedshiftCluster, 'aws_redshift_cluster')
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :describe_clusters,
+        {
+          clusters: [{ cluster_identifier: "id1" }]
+        }
+      )
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsRedshiftCluster._fetch_remote_resources
+      expect(remote_resources.length).to eq(1)
+    end
+  end
+end

data/spec/resources/aws_route53_record_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsRoute53Record") do
+  let(:aws_client) { AwsClients.route53 }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsRoute53Record, 'aws_route53_record')
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :list_hosted_zones,
+        {
+          hosted_zones: [
+            { id: 'id1', name: "zone1", caller_reference: "foo" }
+          ],
+          is_truncated: false,
+          max_items: 100,
+          marker: "foo"
+        }
+      )
+      aws_client.stub_responses(
+        :list_resource_record_sets,
+        {
+          resource_record_sets: [
+            { name: 'name1', type: 'A', ttl: 3600, resource_records: [{ value: "8.8.8.8" }] },
+            { name: 'name1', type: 'CNAME', ttl: 300, resource_records: [{ value: "0.0.0.0" }] }
+          ],
+          is_truncated: false,
+          max_items: 100
+        }
+      )
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsRoute53Record._fetch_remote_resources
+      expect(remote_resources.length).to eq(2)
+    end
+  end
+end

data/spec/resources/aws_route53_zone_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsRoute53Zone") do
+  let(:aws_client) { AwsClients.route53 }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsRoute53Zone, 'aws_route53_zone')
+
+  describe '#_fetch_remote_resources' do
+    before do
+      aws_client.stub_responses(
+        :list_hosted_zones, {
+          hosted_zones: [
+            { id: '123',  name: "testzone", caller_reference: "test" },
+            { id: '1234', name: "anothertestzone", caller_reference: "test" }
+          ],
+          is_truncated: false,
+          max_items: 100,
+          marker: "foo"
+        }
+      )
+    end
+
+    it 'should create an array of hashes from the AWS response' do
+      resources = GeoEngineer::Resources::AwsRoute53Zone._fetch_remote_resources
+      expect(resources.count).to eql(2)
+
+      testzone = resources.first
+      expect(testzone[:_terraform_id]).to eql('123')
+      expect(testzone[:_geo_id]).to eql('testzone')
+    end
+  end
+end

data/spec/resources/aws_s3_bucket_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsS3Bucket") do
+  common_resource_tests(GeoEngineer::Resources::AwsS3Bucket, 'aws_s3_bucket')
+
+  describe "validations" do
+    it 'should validate that policy is valid JSON' do
+      s3b = GeoEngineer::Resources::AwsS3Bucket.new('type', 'id') {
+        bucket "bucket"
+        policy "}}" # invalid JSON
+      }
+      expect(s3b.errors.length).to eq 1
+
+      s3g = GeoEngineer::Resources::AwsS3Bucket.new('type', 'id') {
+        bucket "bucket"
+        policy "{}" # valid JSON
+      }
+      expect(s3g.errors.length).to eq 0
+    end
+  end
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      s3 = AwsClients.s3
+      stub = s3.stub_data(
+        :list_buckets,
+        {
+          buckets: [
+            { name: 'name1' },
+            { name: 'name2' }
+          ]
+        }
+      )
+      s3.stub_responses(:list_buckets, stub)
+      remote_resources = GeoEngineer::Resources::AwsS3Bucket._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_security_group_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSecurityGroup") do
+  common_resource_tests(GeoEngineer::Resources::AwsSecurityGroup, 'aws_security_group')
+  name_tag_geo_id_tests(GeoEngineer::Resources::AwsSecurityGroup)
+
+  describe "validations" do
+    it 'should flatten cidr blocks (allows for easier definition)' do
+      res = GeoEngineer::Resources::AwsSecurityGroup.new('type', 'id') {
+        ingress {
+          cidr_blocks [[1], 2, [[3]]]
+        }
+      }
+      res.flatten_cidr_and_sg_blocks
+      expect(res.ingress.cidr_blocks).to eq [1, 2, 3]
+    end
+
+    it 'should validate_correct_cidr_blocks' do
+      good_cidrs = GeoEngineer::Resources::AwsSecurityGroup.new('type', 'id') {
+        ingress {
+          cidr_blocks ["0.0.0.0/32", '255.255.255.255/0']
+        }
+      }
+      expect(good_cidrs.validate_correct_cidr_blocks.length).to eq 0
+
+      bad_cidrs = GeoEngineer::Resources::AwsSecurityGroup.new('type', 'id') {
+        ingress {
+          cidr_blocks ["0.0.0.0/33", '256.255.255.255/0', 'nonsence']
+        }
+      }
+
+      expect(bad_cidrs.validate_correct_cidr_blocks.length).to eq 3
+    end
+  end
+
+  describe "_terraform_id and _geo_id" do
+    it 'should get geo_id from tags Name' do
+      res = GeoEngineer::Resources::AwsSecurityGroup.new('type', 'id') {
+        tags {
+          Name 'geo_id'
+        }
+      }
+      expect(res._geo_id).to eq 'geo_id'
+    end
+
+    it 'should get terraform_id from remote by matching geo_ids' do
+      GeoEngineer::Resources::AwsSecurityGroup.clear_remote_resource_cache
+      remote_resources = [{ _geo_id: 'geo_id', _terraform_id: 't_id' }]
+      allow(GeoEngineer::Resources::AwsSecurityGroup).to(
+        receive(:_fetch_remote_resources).and_return(remote_resources)
+      )
+
+      res = GeoEngineer::Resources::AwsSecurityGroup.new('type', 'id') {
+        tags {
+          Name 'geo_id'
+        }
+      }
+      expect(res.remote_resource).to_not be_nil
+      expect(res._terraform_id).to eq 't_id'
+    end
+  end
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      ec2 = AwsClients.ec2
+      stub = ec2.stub_data(
+        :describe_security_groups,
+        {
+          security_groups: [
+            { group_name: 'name1', group_id: 'id1', tags: [{ key: 'Name', value: 'one' }] },
+            { group_name: 'name2', group_id: 'id2', tags: [{ key: 'Name', value: 'two' }] }
+          ]
+        }
+      )
+      ec2.stub_responses(:describe_security_groups, stub)
+      remote_resources = GeoEngineer::Resources::AwsSecurityGroup._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_ses_receipt_rule.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSesReceiptRule") do
+  common_resource_tests(GeoEngineer::Resources::AwsSesReceiptRule,
+                        'aws_ses_policy')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      ses = AwsClients.ses
+      # ses.list_policies.policies
+      stub = ses.stub_data(
+        :describe_active_receipt_rule_set,
+        {
+          rules: [
+            {
+              name: 'FakeRule',
+              enabled: true,
+              recipients: ["fake_emal@test123.com"]
+            },
+            {
+              name: 'FakeRule',
+              enabled: true,
+              recipients: ["fake_emal@test123.com"]
+            }
+          ]
+        }
+      )
+      sns.stub_responses(:describe_active_receipt_rule_set, stub)
+      remote_resources = GeoEngineer::Resources::AwsSesReceiptRule._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_ses_receipt_rule_set.rb

@@ -0,0 +1,25 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSesReceiptRuleSet") do
+  common_resource_tests(GeoEngineer::Resources::AwsSesReceiptRuleSet,
+                        'aws_ses_receipt_rule_set')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      ses = AwsClients.ses
+      # ses.list_receipt_rule_sets.rule_sets
+      stub = ses.stub_data(
+        :list_receipt_rule_sets,
+        {
+          rule_sets: [
+            { name: "fake-rule-set", created_timestamp: "2016-10-19 20:19:29 UTC" },
+            { name: "fake-rule-set-2", created_timestamp: "2016-10-19 20:19:29 UTC" }
+          ]
+        }
+      )
+      sns.stub_responses(:list_receipt_rule_sets, stub)
+      remote_resources = GeoEngineer::Resources::AwsSesReceiptRuleSet._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_sns_topic_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSnsTopic") do
+  common_resource_tests(GeoEngineer::Resources::AwsSnsTopic, 'aws_sns_topic')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      sns = AwsClients.sns
+      stub = sns.stub_data(
+        :list_topics,
+        {
+          topics: [
+            { topic_arn: 'arn:aws:sns:us-east-1:123456789012:fake_arn' },
+            { topic_arn: 'arn:aws:sns:us-east-1:123456789012:another_fake_arn' }
+          ]
+        }
+      )
+      sns.stub_responses(:list_topics, stub)
+      remote_resources = GeoEngineer::Resources::AwsSnsTopic._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_sns_topic_subscription.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSnsTopic") do
+  common_resource_tests(GeoEngineer::Resources::AwsSnsTopicSubscription,
+                        'aws_sns_topic_subscription')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      sns = AwsClients.sns
+      # list_subscriptions.subscriptions
+      stub = sns.stub_data(
+        :list_subscriptions,
+        {
+          subscriptions: [
+            {
+              subscription_arn: 'arn:aws:sns:us-east-1:123456789012:fake_arn:8b93e9cd-ef23-47f3',
+              topic_arn: 'arn:aws:sns:us-east-1:123456789012:fake_arn',
+              endpoint: 'arn:aws:sqs:us-east-1:123456789012:fake_arn',
+              protocol: 'sqs'
+            },
+            {
+              subscription_arn: 'arn:aws:sns:us-east-1:123456789012:fake_arn:8b93e9cd-ef23-47f3',
+              topic_arn: 'arn:aws:sns:us-east-1:123456789012:fake_arn',
+              endpoint: 'arn:aws:sqs:us-east-1:123456789012:fake_arn',
+              protocol: 'sqs'
+            }
+          ]
+        }
+      )
+      sns.stub_responses(:list_subscriptions, stub)
+      remote_resources = GeoEngineer::Resources::AwsSnsTopicSubscription._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_sqs_queue_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsSqsQueue") do
+  common_resource_tests(GeoEngineer::Resources::AwsSqsQueue, 'aws_sqs_queue')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      sqs = AwsClients.sqs
+      stub = sqs.stub_data(
+        :list_queues,
+        {
+          queue_urls: ["https://www.qqq.com/path/name1", "https://www.qqq.com/path/name2"]
+        }
+      )
+      sqs.stub_responses(:list_queues, stub)
+      remote_resources = GeoEngineer::Resources::AwsSqsQueue._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/rubocop_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'open3'
+
+describe 'rubocop' do
+  it 'should validate the code style' do
+    puts ""
+    puts "Starting Rubocop Scan"
+    stdout, _stderr, status = Open3.capture3('bundle exec rubocop')
+    expect(status.success?).to eq(true), stdout
+    puts "Finished Rubocop Scan"
+    puts ""
+  end
+end