geoengineer 0.1.0

data/spec/resource_spec.rb

@@ -0,0 +1,169 @@
+require_relative './spec_helper'
+
+describe("GeoEngineer::Resource") do
+  describe '#remote_resource' do
+    class GeoEngineer::RemoteResources < GeoEngineer::Resource
+      def self._fetch_remote_resources
+        [{ _geo_id: "geo_id1" }, { _geo_id: "geo_id2" }, { _geo_id: "geo_id2" }]
+      end
+    end
+
+    it 'should return a list of resources' do
+      rem_res = GeoEngineer::RemoteResources.new('rem', 'id') {
+        _geo_id "geo_id1"
+      }
+
+      norem_res = GeoEngineer::RemoteResources.new('rem', 'id') {
+        _geo_id "geo_id3"
+      }
+
+      expect(rem_res.remote_resource.nil?).to eq false
+      expect(norem_res.remote_resource.nil?).to eq true
+    end
+
+    it 'should error if you match more than one' do
+      rem = GeoEngineer::RemoteResources.new('rem', 'id') {
+        _geo_id "geo_id2"
+      }
+      expect { rem.remote_resource }.to raise_error(StandardError)
+    end
+  end
+
+  describe '#to_terraform_json' do
+    it 'should return _terraform_id as primary' do
+      class GeoEngineer::TFJSON < GeoEngineer::Resource
+        after :initialize, -> { _terraform_id "tid" }
+      end
+
+      res = GeoEngineer::TFJSON.new('tf_json', 'ididid') {
+        blue "TRUE"
+        tags {
+          not_blue "FALSE"
+        }
+      }
+
+      tfjson = res.to_terraform_json
+
+      expect(tfjson['blue']).to eq 'TRUE'
+      expect(tfjson['tags'][0]['not_blue']).to eq 'FALSE'
+    end
+  end
+
+  describe '#to_terraform_state' do
+    it 'should return _terraform_id as primary' do
+      class GeoEngineer::TFState < GeoEngineer::Resource
+        after :initialize, -> { _terraform_id "tid" }
+      end
+
+      tfs = GeoEngineer::TFState.new('tf_state', 'asd').to_terraform_state
+      expect(tfs[:type]).to eq 'tf_state'
+      expect(tfs[:primary][:id]).to eq 'tid'
+    end
+
+    it 'should return _terraform_id as primary' do
+      class GeoEngineer::TFState < GeoEngineer::Resource
+        after :initialize, -> { _terraform_id "tid" }
+      end
+
+      tfs = GeoEngineer::TFState.new('tf_state', 'asd').to_terraform_state
+      expect(tfs[:type]).to eq 'tf_state'
+      expect(tfs[:primary][:id]).to eq 'tid'
+    end
+  end
+
+  describe '#fetch_remote_resources' do
+    it 'should return a list of resources' do
+      class GeoEngineer::FetchableResources < GeoEngineer::Resource
+        def self._fetch_remote_resources
+          [{ _geo_id: "geoid" }]
+        end
+      end
+
+      resources = GeoEngineer::FetchableResources.fetch_remote_resources()
+      expect(resources.length).to eq 1
+      expect(resources[0]._geo_id).to eq "geoid"
+    end
+  end
+
+  describe '#validate_required_subresource' do
+    it 'should return errors if it does not have a tag' do
+      class GeoEngineer::HasSRAttrResource < GeoEngineer::Resource
+        validate -> { validate_required_subresource :tags }
+        after :initialize, -> { _terraform_id "tid'" }
+      end
+      not_blue = GeoEngineer::HasSRAttrResource.new('has_attr', 'id') {}
+      with_blue = GeoEngineer::HasSRAttrResource.new('has_attr', 'id') {
+        tags {
+          blue "True"
+        }
+      }
+      expect(not_blue.errors.length).to eq 1
+      expect(with_blue.errors.length).to eq 0
+    end
+  end
+
+  describe '#validate_subresource_required_attributes' do
+    it 'should return errors if it does not have a tag' do
+      class GeoEngineer::HasSRAttrResource < GeoEngineer::Resource
+        validate -> { validate_subresource_required_attributes :tags, [:blue] }
+        after :initialize, -> { _terraform_id "tid'" }
+      end
+      not_blue = GeoEngineer::HasSRAttrResource.new('has_attr', 'id') {
+        tags {}
+      }
+      with_blue = GeoEngineer::HasSRAttrResource.new('has_attr', 'id') {
+        tags {
+          blue "True"
+        }
+      }
+      expect(not_blue.errors.length).to eq 1
+      expect(with_blue.errors.length).to eq 0
+    end
+  end
+
+  describe '#validate_required_attributes' do
+    it 'should return errors if it does not have a tag' do
+      class GeoEngineer::HasAttrResource < GeoEngineer::Resource
+        validate -> { validate_required_attributes [:blue] }
+        after :initialize, -> { _terraform_id "tid'" }
+      end
+      not_blue = GeoEngineer::HasAttrResource.new('has_attr', 'id')
+      with_blue = GeoEngineer::HasAttrResource.new('has_attr', 'id') {
+        blue "True"
+      }
+      expect(not_blue.errors.length).to eq 1
+      expect(with_blue.errors.length).to eq 0
+    end
+  end
+
+  describe '#validate_has_tag' do
+    it 'should return errors if it does not have a tag' do
+      class GeoEngineer::HasTagResource < GeoEngineer::Resource
+        validate -> { validate_has_tag :blue }
+        after :initialize, -> { _terraform_id "tid'" }
+      end
+      not_blue = GeoEngineer::HasTagResource.new('has_tag', 'id')
+      with_blue = GeoEngineer::HasTagResource.new('has_tag', 'id') {
+        tags {
+          blue "True"
+        }
+      }
+      expect(not_blue.errors.length).to eq 1
+      expect(with_blue.errors.length).to eq 0
+    end
+  end
+
+  describe 'class method' do
+    describe('#type_from_class_name') do
+      it 'should return resource' do
+        expect(GeoEngineer::Resource.type_from_class_name).to eq 'resource'
+      end
+
+      it 'should remove module' do
+        class GeoEngineer::ResourceType < GeoEngineer::Resource
+        end
+        expect(GeoEngineer::ResourceType.type_from_class_name).to eq 'resource_type'
+      end
+    end
+  end
+end

data/spec/resources/aws_db_instance_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsDbInstance") do
+  common_resource_tests(GeoEngineer::Resources::AwsDbInstance, 'aws_db_instance')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      rds = AwsClients.rds
+      stub = rds.stub_data(
+        :describe_db_instances,
+        {
+          db_instances: [
+            { db_instance_identifier: 'name1' },
+            { db_instance_identifier: 'name2' }
+          ]
+        }
+      )
+      rds.stub_responses(:describe_db_instances, stub)
+      remote_resources = GeoEngineer::Resources::AwsDbInstance._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_db_parameter_group_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsDbParameterGroup") do
+  common_resource_tests(GeoEngineer::Resources::AwsDbParameterGroup, 'aws_db_parameter_group')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      rds = AwsClients.rds
+      stub = rds.stub_data(
+        :describe_db_parameter_groups,
+        {
+          db_parameter_groups: [
+            { db_parameter_group_name: 'name1' },
+            { db_parameter_group_name: 'name2' }
+          ]
+        }
+      )
+      rds.stub_responses(:describe_db_parameter_groups, stub)
+      remote_resources = GeoEngineer::Resources::AwsDbParameterGroup._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elasticache_replication_group_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsElasticacheReplicationGroup") do
+  common_resource_tests(
+    GeoEngineer::Resources::AwsElasticacheReplicationGroup,
+    'aws_elasticache_replication_group'
+  )
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elasticache = AwsClients.elasticache
+      stub = elasticache.stub_data(
+        :describe_replication_groups,
+        {
+          replication_groups: [
+            { replication_group_id: 'rg1' },
+            { replication_group_id: 'rg2' }
+          ]
+        }
+      )
+      elasticache.stub_responses(:describe_replication_groups, stub)
+
+      replication_group_class = GeoEngineer::Resources::AwsElasticacheReplicationGroup
+      remote_resources = replication_group_class._fetch_remote_resources
+
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elasticache_subnet_group_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsElasticacheSubnetGroup" do
+  let(:aws_client) { AwsClients.elasticache }
+
+  before { aws_client.setup_stubbing }
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsElasticacheSubnetGroup,
+    'aws_elasticache_subnet_group'
+  )
+
+  describe "#_fetch_remote_resources" do
+    before do
+      aws_client.stub_responses(
+        :describe_cache_subnet_groups,
+        {
+          cache_subnet_groups: [
+            { cache_subnet_group_name: 'cache-subnet-group-1' },
+            { cache_subnet_group_name: 'cache-subnet-group-2' }
+          ]
+        }
+      )
+    end
+
+    it 'should create list of hashes from returned AWS SDK' do
+      remote_resources = GeoEngineer::Resources::AwsElasticacheSubnetGroup._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elasticcache_cluster_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsElasticacheCluster") do
+  common_resource_tests(GeoEngineer::Resources::AwsElasticacheCluster, 'aws_elasticache_cluster')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elasticache = AwsClients.elasticache
+      stub = elasticache.stub_data(
+        :describe_cache_clusters,
+        {
+          cache_clusters: [
+            { cache_cluster_id: 'name1' },
+            { cache_cluster_id: 'name2' }
+          ]
+        }
+      )
+      elasticache.stub_responses(:describe_cache_clusters, stub)
+      remote_resources = GeoEngineer::Resources::AwsElasticacheCluster._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elasticcache_parameter_group_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsElasticacheParameterGroup") do
+  common_resource_tests(
+    GeoEngineer::Resources::AwsElasticacheParameterGroup,
+    'aws_elasticache_parameter_group'
+  )
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elasticache = AwsClients.elasticache
+      stub = elasticache.stub_data(
+        :describe_cache_parameter_groups,
+        {
+          cache_parameter_groups: [
+            { cache_parameter_group_name: 'name1' },
+            { cache_parameter_group_name: 'name2' }
+          ]
+        }
+      )
+      elasticache.stub_responses(:describe_cache_parameter_groups, stub)
+      rr = GeoEngineer::Resources::AwsElasticacheParameterGroup._fetch_remote_resources
+      expect(rr.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elasticsearch_domain_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsElasticsearchDomain") do
+  common_resource_tests(GeoEngineer::Resources::AwsElasticsearchDomain, 'aws_elasticsearch_domain')
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      stub = AwsClients.elasticsearch.stub_data(
+        :list_domain_names,
+        {
+          domain_names: [
+            { domain_name: 'name1' },
+            { domain_name: 'name2' }
+          ]
+        }
+      )
+      AwsClients.elasticsearch.stub_responses(:list_domain_names, stub)
+      remote_resources = GeoEngineer::Resources::AwsElasticsearchDomain._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_elb_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsElb") do
+  common_resource_tests(GeoEngineer::Resources::AwsElb, 'aws_elb')
+
+  describe "validations" do
+    it 'should validate unique lb ports for listeners' do
+      good_elb = GeoEngineer::Resources::AwsElb.new('type', 'id') {
+        name "name"
+        listener {
+          instance_port 100
+          instance_protocol 'tcp'
+          lb_port 100
+          lb_protocol 'tcp'
+        }
+
+        listener {
+          instance_port 100
+          instance_protocol 'tcp'
+          lb_port 101
+          lb_protocol 'tcp'
+        }
+      }
+
+      expect(good_elb.errors.length).to eq 0
+
+      bad_elb = GeoEngineer::Resources::AwsElb.new('type', 'id') {
+        name "name"
+        listener {
+          instance_port 100
+          instance_protocol 'tcp'
+          lb_port 100
+          lb_protocol 'tcp'
+        }
+
+        listener {
+          instance_port 100
+          instance_protocol 'tcp'
+          lb_port 100
+          lb_protocol 'tcp'
+        }
+      }
+
+      expect(bad_elb.errors.length).to eq 1
+    end
+  end
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      elb = AwsClients.elb
+      stub = elb.stub_data(
+        :describe_load_balancers,
+        {
+          load_balancer_descriptions: [
+            { load_balancer_name: 'name1' },
+            { load_balancer_name: 'name2' }
+          ]
+        }
+      )
+      elb.stub_responses(:describe_load_balancers, stub)
+      remote_resources = GeoEngineer::Resources::AwsElb._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end

data/spec/resources/aws_iam_policy.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe("GeoEngineer::Resources::AwsIamPolicy") do
+  common_resource_tests(GeoEngineer::Resources::AwsIamPolicy,
+                        'aws_iam_policy')
+
+  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_policies,
+        {
+          policies: [
+            {
+              policy_name: 'FakePolicy',
+              policy_id: 'ANTIPASTAAC2ZFSLA',
+              arn: 'arn:aws:iam::123456789012:policy/FakePolicy',
+              path: '/'
+            },
+            {
+              policy_name: 'FakePolicy',
+              policy_id: 'ANTIPASTAAC2ZFSLA',
+              arn: 'arn:aws:iam::123456789012:policy/FakePolicy',
+              path: '/'
+            }
+          ]
+        }
+      )
+      sns.stub_responses(:list_policies, stub)
+      remote_resources = GeoEngineer::Resources::AwsIamPolicy._fetch_remote_resources
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end