geoengineer 0.1.0 → 0.1.1

data/spec/resources/aws_iam_group_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resource::AwsIamGroup" do
+  common_resource_tests(GeoEngineer::Resources::AwsIamGroup, 'aws_iam_group')
+
+  let(:aws_client) { AwsClients.iam }
+
+  before { aws_client.setup_stubbing }
+
+  describe '#_fetch_remote_resources' do
+    before do
+      aws_client.stub_responses(
+        :list_groups, {
+          groups: [
+            {
+              group_name: "Some-IAM-Group",
+              group_id: "AAAAAAAAAAAAAAAAAAAAA",
+              path: "/",
+              arn: "arn:aws:iam::000000000000:group/Some-IAM-Group",
+              create_date: Time.parse('2014-12-01T00:00:00Z')
+            },
+            {
+              group_name: "Another-IAM-group",
+              group_id: "AAAAAAAAAAAAAAAAAAAAA",
+              path: "/",
+              arn: "arn:aws:iam::000000000000:group/Another-IAM-group",
+              create_date: Time.parse('2014-12-01T00:00:00Z')
+            }
+          ]
+        }
+      )
+    end
+
+    it 'should create a list of hashes returned AWS SDK' do
+      resources = GeoEngineer::Resources::AwsIamGroup._fetch_remote_resources
+      expect(resources.count).to eql(2)
+
+      test_iam_group = resources.first
+      expect(test_iam_group[:_terraform_id]).to eql("Some-IAM-Group")
+      expect(test_iam_group[:_geo_id]).to eql("Some-IAM-Group")
+    end
+  end
+end

data/spec/resources/aws_iam_policy_attachment_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsIamPolicy" do
+  let(:aws_client) { AwsClients.iam }
+
+  let(:iam_policy) do
+    GeoEngineer::Resources::AwsIamPolicy.new('aws_iam_policy', 'fake_policy') {
+      name 'Fake-Aws-Policy'
+    }
+  end
+
+  let(:iam_policy_attachment) do
+    policy = iam_policy
+
+    GeoEngineer::Resources::AwsIamPolicyAttachment
+      .new('aws_iam_policy_attachment', 'fake_policy_attachment') {
+        _policy policy
+      }
+  end
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsIamPolicyAttachment,
+    'aws_iam_policy_attachment',
+    false
+  )
+
+  describe '#remote_resource' do
+    before do
+      aws_client.stub_responses(
+        :list_policies,
+        {
+          policies: [
+            {
+              arn: 'arn:aws:iam::aws:policy/xyv/FakeAwsARN',
+              policy_name: 'Fake-Aws-Policy'
+            }
+          ]
+        }
+      )
+
+      aws_client.stub_responses(
+        :list_entities_for_policy,
+        {
+          policy_users:  [
+            { user_name: 'fake-user' },
+            { user_name: 'fake-user-2' }
+          ],
+          policy_groups: [
+            { group_name: 'fake-group' }
+          ],
+          policy_roles: [
+            { role_name: 'fake-policy' }
+          ]
+        }
+      )
+    end
+
+    context 'with a policy' do
+      context 'when the policy does not have a remote resource' do
+        before { expect(iam_policy_attachment).to receive(:remote_resource).and_return(nil) }
+
+        it 'should not have a remote resource' do
+          expect(iam_policy_attachment.remote_resource).to be_nil
+        end
+      end
+
+      it 'should create a hash from the response' do
+        remote_resource = iam_policy_attachment.remote_resource_params
+
+        expect(remote_resource[:name]).to eql 'Fake-Aws-Policy'
+        expect(remote_resource[:_terraform_id]).to eql 'arn:aws:iam::aws:policy/xyv/FakeAwsARN'
+        expect(remote_resource[:_geo_id]).to eql 'Fake-Aws-Policy'
+
+        expect(remote_resource[:users].length).to eql(2)
+        expect(remote_resource[:groups].length).to eql(1)
+        expect(remote_resource[:groups].length).to eql(1)
+      end
+    end
+  end
+end

data/spec/resources/{aws_iam_policy.rb → aws_iam_policy_spec.rb}

@@ -1,14 +1,16 @@
 require_relative '../spec_helper'
 
-describe("GeoEngineer::Resources::AwsIamPolicy") do
+describe "GeoEngineer::Resources::AwsIamPolicy" do
+  let(:iam_client) { AwsClients.iam }
+
   common_resource_tests(GeoEngineer::Resources::AwsIamPolicy,
                         'aws_iam_policy')
 
+  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_policies,
         {
           policies: [
@@ -27,7 +29,6 @@ describe("GeoEngineer::Resources::AwsIamPolicy") do
           ]
         }
       )
-      sns.stub_responses(:list_policies, stub)
       remote_resources = GeoEngineer::Resources::AwsIamPolicy._fetch_remote_resources
       expect(remote_resources.length).to eq 2
     end

data/spec/resources/aws_iam_role_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsIamRole" do
+  let(:aws_client) { AwsClients.iam }
+
+  common_resource_tests(GeoEngineer::Resources::AwsIamRole, 'aws_iam_role')
+
+  before { aws_client.setup_stubbing }
+
+  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: ""
+          }
+        ] }
+      )
+    end
+
+    it 'should create a list of hashes from the AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsIamRole._fetch_remote_resources
+      expect(remote_resources.length).to eql 2
+
+      test_role = remote_resources.first
+
+      expect(test_role[:_terraform_id]).to eql('Some-IAM-role')
+      expect(test_role[:_geo_id]).to eql('Some-IAM-role')
+      expect(test_role[:name]).to eql('Some-IAM-role')
+    end
+  end
+end

data/spec/resources/aws_internet_gateway_spec.rb

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

data/spec/resources/aws_lambda_alias_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsLambdaAlias") do
+  let(:aws_client) { AwsClients.lambda }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsLambdaAlias, 'aws_lambda_alias')
+
+  describe "#_fetch_remote_resources" do
+    before 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" }
+          ]
+        }
+      )
+      aws_client.stub_responses(
+        :list_aliases, {
+          aliases: [
+            { name: "foonew", alias_arn: "arn:aws:lambda:alias", function_version: "1" }
+          ]
+        }
+      )
+    end
+
+    after do
+      aws_client.stub_responses(:list_functions, {})
+      aws_client.stub_responses(:list_aliases, {})
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsLambdaAlias._fetch_remote_resources
+      expect(remote_resources.length).to eq(2)
+    end
+  end
+end

data/spec/resources/aws_lambda_event_source_mapping_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsLambdaEventSourceMapping do
+  let(:aws_client) { AwsClients.lambda }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsLambdaEventSourceMapping,
+    'aws_lambda_event_source_mapping'
+  )
+
+  describe '#_fetch_remote_resources' do
+    before do
+      aws_client.stub_responses(
+        :list_event_source_mappings, {
+          event_source_mappings: [
+            {
+              uuid: "1",
+              event_source_arn: "arn:aws:kinesis:one",
+              function_arn: "arn:aws:lambda:function:foo"
+            },
+            {
+              uuid: "2",
+              event_source_arn: "arn:aws:kinesis:two",
+              function_arn: "arn:aws:lambda:function:bar:beta"
+            }
+          ]
+        }
+      )
+    end
+
+    after { aws_client.stub_responses(:list_event_source_mappings, {}) }
+
+    it 'should create an array of hashes from the AWS response' do
+      resources = GeoEngineer::Resources::AwsLambdaEventSourceMapping._fetch_remote_resources
+      expect(resources.count).to eql(2)
+    end
+  end
+
+  describe "#_extract_name_from_arn" do
+    it "returns nil if ARN does not contain function" do
+      expect(described_class._extract_name_from_arn("foo_bar")).to be_nil
+    end
+
+    it "returns item directly after function in ARN" do
+      expect(described_class._extract_name_from_arn("function:bar")).to eq('bar')
+      expect(described_class._extract_name_from_arn("aws:function:baz")).to eq('baz')
+      expect(described_class._extract_name_from_arn("aws:function:foo:qux")).to eq('foo')
+      expect(described_class._extract_name_from_arn("aws:function")).to be_nil
+    end
+  end
+end

data/spec/resources/aws_lambda_function_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsLambdaFunction") do
+  let(:aws_client) { AwsClients.lambda }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsLambdaFunction, 'aws_lambda_function')
+
+  describe '#_fetch_remote_resources' do
+    before 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" }
+          ]
+        }
+      )
+    end
+
+    after { aws_client.stub_responses(:list_functions, {}) }
+
+    it 'should create an array of hashes from the AWS response' do
+      resources = GeoEngineer::Resources::AwsLambdaFunction._fetch_remote_resources
+      expect(resources.count).to eql(2)
+    end
+  end
+end

data/spec/resources/aws_lambda_permission_spec.rb

@@ -0,0 +1,90 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsLambdaPermission do
+  let(:aws_client) { AwsClients.lambda }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(GeoEngineer::Resources::AwsLambdaPermission, 'aws_lambda_permission')
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :list_functions, {
+          functions: [
+            { function_name: "foo", role: "arn:aws:iam:one", handler: "export.foo", version: "1" },
+            { function_name: "bar", role: "arn:aws:iam:two", handler: "export.bar", version: "1" }
+          ]
+        }
+      )
+      aws_client.stub_responses(
+        :get_policy, {
+          policy: { Statement: [{ Sid: Random.rand(1000).to_s }] }.to_json
+        }
+      )
+    end
+
+    after do
+      aws_client.stub_responses(:list_functions, {})
+      aws_client.stub_responses(:get_policy, {})
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsLambdaPermission._fetch_remote_resources
+      expect(remote_resources.length).to eq(2)
+    end
+  end
+
+  describe '#_parse_policy' do
+    it "returns nil is there is a JSON Parse error" do
+      expect(described_class._parse_policy("{ foo:  }")).to eq(nil)
+    end
+
+    context "with valid JSON" do
+      it "returns a hash with symbols for keys" do
+        policy = { foo: "bar", baz: ["qux"] }
+
+        expect(described_class._parse_policy(policy.to_json)).to eq(policy)
+        expect(described_class._parse_policy(policy.to_json).include?(:foo)).to eq(true)
+      end
+    end
+  end
+
+  describe '#_deep_symbolize_keys' do
+    let(:simple_obj) { JSON.parse({ foo: "bar", baz: "qux" }.to_json) }
+    let(:complex_obj) do
+      JSON.parse(
+        {
+          foo: {
+            bar: {
+              baz: [
+                { qux: "quack" }
+              ]
+            }
+          },
+          bar: [
+            { foo: "bar" },
+            nil,
+            [{ baz: "qux" }],
+            1,
+            "baz"
+          ]
+        }.to_json
+      )
+    end
+
+    it "converts top level keys to symbols" do
+      expect(simple_obj.keys.include?(:foo)).to eq(false)
+      expect(simple_obj.keys.include?("foo")).to eq(true)
+      converted = described_class._deep_symbolize_keys(simple_obj)
+      expect(converted.keys.include?(:foo)).to eq(true)
+      expect(converted.keys.include?("foo")).to eq(false)
+    end
+
+    it "converts deeply nested keys to symbols" do
+      converted = described_class._deep_symbolize_keys(complex_obj)
+      expect(converted[:foo][:bar][:baz].first[:qux]).to eq("quack")
+      expect(converted[:bar].first[:foo]).to eq("bar")
+    end
+  end
+end

data/spec/resources/aws_main_route_table_association_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsMainRouteTableAssociation do
+  common_resource_tests(
+    GeoEngineer::Resources::AwsMainRouteTableAssociation,
+    'aws_main_route_table_association'
+  )
+
+  describe "#_fetch_remote_resources" do
+    let(:ec2) { AwsClients.ec2 }
+    before do
+      stub = ec2.stub_data(
+        :describe_route_tables,
+        {
+          route_tables: [
+            {
+              route_table_id: 'name1',
+              vpc_id: "1",
+              tags: [{ key: 'Name', value: 'one' }],
+              associations: [
+                {
+                  route_table_association_id: '1',
+                  subnet_id: 's-1',
+                  route_table_id: 'r-1',
+                  main: false
+                }
+              ]
+            },
+            {
+              route_table_id: 'name2',
+              vpc_id: "1",
+              tags: [{ key: 'Name', value: 'two' }],
+              associations: [
+                {
+                  route_table_association_id: '2',
+                  subnet_id: 's-2',
+                  route_table_id: 'r-2',
+                  main: true
+                }
+              ]
+            }
+          ]
+        }
+      )
+      ec2.stub_responses(:describe_route_tables, stub)
+    end
+
+    after do
+      ec2.stub_responses(:describe_route_tables, [])
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = described_class._fetch_remote_resources
+      expect(remote_resources.length).to eq(1)
+    end
+  end
+end