geoengineer 0.1.1 → 0.1.2

data/spec/resources/aws_cloudwatch_event_target_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsCloudwatchEventTarget") do
+  let(:aws_client) { AwsClients.cloudwatchevents }
+
+  before do
+    aws_client.setup_stubbing
+  end
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsCloudwatchEventTarget,
+    'aws_cloudwatch_event_target'
+  )
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :list_rules,
+        {
+          rules:
+          [
+            {
+              name: "test",
+              arn: "arn:aws:cloudwatchevents:us-east-1:1234567890:test",
+              state: "ENABLED",
+              schedule_expression: "rate(5 minutes)"
+            }
+          ]
+        }
+      )
+    end
+    before do
+      aws_client.stub_responses(
+        :list_targets_by_rule,
+        {
+          targets:
+          [
+            {
+              id: "test",
+              arn: "arn:aws:cloudwatchevents:us-east-1:1234567890:test",
+              input: nil,
+              input_path: nil
+            }
+          ]
+        }
+      )
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsCloudwatchEventTarget._fetch_remote_resources
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_dynamodb_table_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsDynamodbTable" do
+  let(:aws_client) { AwsClients.dynamo }
+
+  common_resource_tests(GeoEngineer::Resources::AwsDynamodbTable, 'aws_dynamodb_table')
+
+  describe '#_fetch_remote_resources' do
+    before do
+      aws_client.stub_responses(
+        :list_tables, { table_names: ["dynamo_name1", "dynamo_name2"] }
+      )
+    end
+
+    it 'should create an array of hashes from the AWS response' do
+      resources = GeoEngineer::Resources::AwsDynamodbTable._fetch_remote_resources
+      expect(resources.count).to eql 2
+
+      test_dynamot = resources.first
+      expect(test_dynamot[:_terraform_id]).to eql "dynamo_name1"
+      expect(test_dynamot[:_geo_id]).to eql "dynamo_name1"
+    end
+  end
+end

data/spec/resources/aws_iam_role_spec.rb

@@ -10,24 +10,27 @@ describe "GeoEngineer::Resources::AwsIamRole" do
   describe "#_fetch_remote_resources" do
     before do
       aws_client.stub_responses(
-        :list_roles, { roles: [
-          {
-            role_name: 'Some-IAM-role',
-            arn: "arn:aws:iam::123456789123:role/some-iam-role",
-            path: "/",
-            role_id: "XXXXXXXXXXXXXXXXXXXXY",
-            create_date: Time.parse("2016-12-13 01:00:06 UTC"),
-            assume_role_policy_document: ""
-          },
-          {
-            role_name: 'Another-IAM-role',
-            arn: "arn:aws:iam::123456789123:role/another-iam-role",
-            path: "/",
-            role_id: "XXXXXXXXXXXXXXXXXXXXY",
-            create_date: Time.parse("2016-12-13 01:00:06 UTC"),
-            assume_role_policy_document: ""
-          }
-        ] }
+        :list_roles,
+        {
+          roles: [
+            {
+              role_name: 'Some-IAM-role',
+              arn: "arn:aws:iam::123456789123:role/some-iam-role",
+              path: "/",
+              role_id: "XXXXXXXXXXXXXXXXXXXXY",
+              create_date: Time.parse("2016-12-13 01:00:06 UTC"),
+              assume_role_policy_document: ""
+            },
+            {
+              role_name: 'Another-IAM-role',
+              arn: "arn:aws:iam::123456789123:role/another-iam-role",
+              path: "/",
+              role_id: "XXXXXXXXXXXXXXXXXXXXY",
+              create_date: Time.parse("2016-12-13 01:00:06 UTC"),
+              assume_role_policy_document: ""
+            }
+          ]
+        }
       )
     end
 

data/spec/resources/aws_iam_rule_policy_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsIamRolePolicy do
+  let(:iam_client) { AwsClients.iam }
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsIamRolePolicy,
+    'aws_iam_role_policy'
+  )
+
+  before { iam_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      iam_client.stub_responses(
+        :list_roles,
+        {
+          roles: [
+            {
+              role_name: 'Some-IAM-role',
+              arn: "arn:aws:iam::123456789123:role/some-iam-role",
+              path: "/",
+              role_id: "XXXXXXXXXXXXXXXXXXXXY",
+              create_date: Time.parse("2016-12-13 01:00:06 UTC"),
+              assume_role_policy_document: ""
+            }
+          ]
+        }
+      )
+      iam_client.stub_responses(
+        :list_role_policies,
+        {
+          policy_names: ["Some-Policy-Name"],
+          is_truncated: false
+        }
+      )
+      iam_client.stub_responses(
+        :get_role_policy,
+        {
+          role_name: 'Some-IAM-role',
+          policy_name: 'Some-Policy-Name',
+          policy_document: "{ Some Policy Here... }"
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsIamRolePolicy._fetch_remote_resources
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/{aws_iam_user.rb → aws_iam_user_spec.rb}

@@ -1,14 +1,16 @@
 require_relative '../spec_helper'
 
 describe("GeoEngineer::Resources::AwsIamUser") do
+  let(:iam_client) { AwsClients.iam }
+
   common_resource_tests(GeoEngineer::Resources::AwsIamUser,
                         'aws_iam_user')
 
+  before { iam_client.setup_stubbing }
+
   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(
+      iam_client.stub_responses(
         :list_users,
         {
           users: [
@@ -16,18 +18,19 @@ describe("GeoEngineer::Resources::AwsIamUser") do
               user_name: 'FakeUser',
               user_id: 'ANTIPASTAAC2ZFSLA',
               arn: 'arn:aws:iam::123456789012:user/FakeUser',
-              path: '/'
+              path: '/',
+              create_date: Time.parse('2016-03-23 16:33:32 UTC')
             },
             {
               user_name: 'FakeUser',
               user_id: 'ANTIPASTAAC2ZFSLA',
               arn: 'arn:aws:iam::123456789012:user/FakeUser',
-              path: '/'
+              path: '/',
+              create_date: Time.parse('2016-03-23 16:33:32 UTC')
             }
           ]
         }
       )
-      sns.stub_responses(:list_users, stub)
       remote_resources = GeoEngineer::Resources::AwsIamUser._fetch_remote_resources
       expect(remote_resources.length).to eq 2
     end

data/spec/resources/aws_kinesis_stream_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsKinesisStream") do
+  let(:aws_client) { AwsClients.kinesis }
+
+  before do
+    aws_client.setup_stubbing
+    aws_client.stub_responses(
+      :list_streams,
+      {
+        stream_names: [],
+        has_more_streams: false
+      }
+    )
+  end
+
+  common_resource_tests(GeoEngineer::Resources::AwsKinesisStream, 'aws_kinesis_stream')
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :list_streams,
+        {
+          stream_names: ["test"],
+          has_more_streams: false
+        }
+      )
+    end
+    before do
+      aws_client.stub_responses(
+        :describe_stream,
+        {
+          stream_description:
+          {
+            stream_name: "test",
+            stream_arn: "arn:aws:kinesis:us-east-1:1234567890:stream/test",
+            stream_status: "ACTIVE",
+            shards: [],
+            has_more_shards: false,
+            retention_period_hours: 24,
+            enhanced_monitoring: []
+          }
+        }
+      )
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsKinesisStream._fetch_remote_resources
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_lambda_alias_spec.rb

@@ -1,6 +1,6 @@
 require_relative '../spec_helper'
 
-describe("GeoEngineer::Resources::AwsLambdaAlias") do
+describe GeoEngineer::Resources::AwsLambdaAlias do
   let(:aws_client) { AwsClients.lambda }
 
   before { aws_client.setup_stubbing }
@@ -12,8 +12,18 @@ describe("GeoEngineer::Resources::AwsLambdaAlias") do
       aws_client.stub_responses(
         :list_functions, {
           functions: [
-            { function_name: "foo", role: "arn:aws:iam:one", handler: "export.foo" },
-            { function_name: "bar", role: "arn:aws:iam:two", handler: "export.bar" }
+            {
+              function_name: "foo",
+              function_arn: "arn:aws:lambda:us-east-1:123:function:foo",
+              role: "arn:aws:iam:one",
+              handler: "export.foo"
+            },
+            {
+              function_name: "bar",
+              function_arn: "arn:aws:lambda:us-east-1:123:function:bar",
+              role: "arn:aws:iam:two",
+              handler: "export.bar"
+            }
           ]
         }
       )
@@ -35,5 +45,14 @@ describe("GeoEngineer::Resources::AwsLambdaAlias") do
       remote_resources = GeoEngineer::Resources::AwsLambdaAlias._fetch_remote_resources
       expect(remote_resources.length).to eq(2)
     end
+
+    it 'should match a local resource to the remote resource' do
+      subject = described_class.new('aws_lambda_alias', 'foo') {
+        name "foonew"
+        function_name "arn:aws:lambda:us-east-1:123:function:foo"
+        function_version 1
+      }
+      expect(subject.remote_resource).to_not be_nil
+    end
   end
 end

data/spec/resources/aws_load_balancer_backend_server_policy_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsLoadBalancerBackendServerPolicy do
+  let(:elb_client) { AwsClients.elb }
+
+  common_resource_tests(GeoEngineer::Resources::AwsLoadBalancerBackendServerPolicy,
+                        'aws_load_balancer_backend_server_policy')
+
+  before { elb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elb_client.stub_responses(
+        :describe_load_balancers,
+        {
+          load_balancer_descriptions: [
+            {
+              load_balancer_name: "test",
+              backend_server_descriptions: [
+                {
+                  instance_port: 5000,
+                  policy_names: ["test"]
+                }
+              ]
+            },
+            {
+              load_balancer_name: "test",
+              backend_server_descriptions: [
+                {
+                  instance_port: 5000,
+                  policy_names: ["test"]
+                }
+              ]
+            }
+          ]
+        }
+      )
+      remote_resources = described_class._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_load_balancer_policy_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsLoadBalancerPolicy") do
+  let(:elb_client) { AwsClients.elb }
+
+  common_resource_tests(GeoEngineer::Resources::AwsLoadBalancerPolicy,
+                        'aws_load_balancer_policy')
+
+  before { elb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elb_client.stub_responses(
+        :describe_load_balancer_policies,
+        {
+          policy_descriptions: [
+            {
+              policy_name: "ELBSecurityPolicy-2015-05",
+              policy_type_name: "SSLNegotiationPolicyType"
+            }
+          ]
+        }
+      )
+      elb_client.stub_responses(
+        :describe_load_balancers,
+        {
+          load_balancer_descriptions: [
+            {
+              load_balancer_name: "test",
+              backend_server_descriptions: [
+                {
+                  instance_port: 5000,
+                  policy_names: ["test"]
+                }
+              ]
+            }
+          ]
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsLoadBalancerPolicy._fetch_remote_resources
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_network_acl_rule_spec.rb

@@ -1,6 +1,6 @@
 require_relative '../spec_helper'
 
-describe("GeoEngineer::Resources::AwsNetworkAclRule") do
+describe GeoEngineer::Resources::AwsNetworkAclRule do
   common_resource_tests(GeoEngineer::Resources::AwsNetworkAclRule, 'aws_network_acl_rule')
 
   describe "#_fetch_remote_resources" do
@@ -70,4 +70,32 @@ describe("GeoEngineer::Resources::AwsNetworkAclRule") do
       expect(subject._terraform_id).to eq("nacl-883681663")
     end
   end
+
+  describe '::_number_for_protocol' do
+    context "when protocol is nil" do
+      it "returns nil" do
+        expect(described_class._number_for_protocol(nil)).to eq(nil)
+      end
+    end
+
+    context "when protocol is already a integer" do
+      it "returns that integer if it is a valid protocol number" do
+        expect(described_class._number_for_protocol(-1)).to eq(-1)
+      end
+
+      it "returns nil if it is not a valid protocol number" do
+        expect(described_class._number_for_protocol(-2)).to eq(nil)
+      end
+    end
+
+    context "when protocol is string" do
+      it "returns the corresponding number for valid protocols" do
+        expect(described_class._number_for_protocol("all")).to eq(-1)
+      end
+
+      it "returns nil for unrecognized protocols" do
+        expect(described_class._number_for_protocol(-2)).to eq(nil)
+      end
+    end
+  end
 end