geoengineer 0.1.3 → 0.1.4

data/lib/geoengineer/utils/aws_clients.rb

@@ -11,80 +11,171 @@ class AwsClients
     @stub_aws || false
   end
 
+  def self.client_params(provider = nil)
+    client_params = { stub_responses: stubbed? }
+    client_params[:region] = provider.region if provider
+    client_params
+  end
+
+  def self.client_cache(provider, client)
+    @client_cache ||= {}
+    key = "#{client.name}_" + (provider&.terraform_id || GeoEngineer::Resource::DEFAULT_PROVIDER)
+    @client_cache[key] ||= client.new(client_params(provider))
+  end
+
   # Clients
-  def self.cloudwatch
-    @aws_cloudwatch ||= Aws::CloudWatch::Client.new({ stub_responses: stubbed? })
+
+  def self.alb(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::ElasticLoadBalancingV2::Client
+    )
+  end
+
+  def self.api_gateway(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::APIGateway::Client
+    )
+  end
+
+  def self.cloudfront(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::CloudFront::Client
+    )
+  end
+
+  def self.cloudwatch(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::CloudWatch::Client
+    )
   end
 
-  def self.cloudwatchevents
-    @aws_cloudwatchevents ||= Aws::CloudWatchEvents::Client.new({ stub_responses: stubbed? })
+  def self.cloudwatchevents(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::CloudWatchEvents::Client
+    )
   end
 
-  def self.dynamo
-    @aws_dynamo ||= Aws::DynamoDB::Client.new({ stub_responses: stubbed? })
+  def self.dynamo(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::DynamoDB::Client
+    )
   end
 
-  def self.ec2
-    @aws_ec2 ||= Aws::EC2::Client.new({ stub_responses: stubbed? })
+  def self.ec2(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::EC2::Client
+    )
   end
 
-  def self.elasticache
-    @aws_elasticache ||= Aws::ElastiCache::Client.new({ stub_responses: stubbed? })
+  def self.elasticache(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::ElastiCache::Client
+    )
   end
 
-  def self.elasticsearch
-    @aws_elasticsearch ||= Aws::ElasticsearchService::Client.new({ stub_responses: stubbed? })
+  def self.elasticsearch(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::ElasticsearchService::Client
+    )
   end
 
-  def self.elb
-    @aws_elb ||= Aws::ElasticLoadBalancing::Client.new({ stub_responses: stubbed? })
+  def self.elb(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::ElasticLoadBalancing::Client
+    )
   end
 
-  def self.iam
-    @aws_iam ||= Aws::IAM::Client.new({ stub_responses: stubbed? })
+  def self.iam(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::IAM::Client
+    )
   end
 
-  def self.kinesis
-    @aws_kinesis ||= Aws::Kinesis::Client.new({ stub_responses: stubbed? })
+  def self.kinesis(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::Kinesis::Client
+    )
   end
 
-  def self.lambda
-    @aws_lambda ||= Aws::Lambda::Client.new({ stub_responses: stubbed? })
+  def self.lambda(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::Lambda::Client
+    )
   end
 
-  def self.rds
-    @aws_rds ||= Aws::RDS::Client.new({ stub_responses: stubbed? })
+  def self.rds(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::RDS::Client
+    )
   end
 
-  def self.redshift
-    @aws_redshift ||= Aws::Redshift::Client.new({ stub_responses: stubbed? })
+  def self.redshift(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::Redshift::Client
+    )
   end
 
-  def self.route53
-    @aws_route53 ||= Aws::Route53::Client.new({ stub_responses: stubbed? })
+  def self.route53(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::Route53::Client
+    )
   end
 
-  def self.s3
-    @aws_s3 ||= Aws::S3::Client.new({ stub_responses: stubbed? })
+  def self.s3(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::S3::Client
+    )
   end
 
-  def self.ses
-    @aws_ses ||= Aws::SES::Client.new({ stub_responses: stubbed? })
+  def self.ses(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::SES::Client
+    )
   end
 
-  def self.sns
-    @aws_sns ||= Aws::SNS::Client.new({ stub_responses: stubbed? })
+  def self.sns(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::SNS::Client
+    )
   end
 
-  def self.sqs
-    @aws_sqs ||= Aws::SQS::Client.new({ stub_responses: stubbed? })
+  def self.sqs(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::SQS::Client
+    )
   end
 
-  def self.cloudtrail
-    @aws_cloudtrail ||= Aws::CloudTrail::Client.new({ stub_responses: stubbed? })
+  def self.cloudtrail(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::CloudTrail::Client
+    )
   end
 
-  def self.kms
-    @aws_kms ||= Aws::KMS::Client.new({ stub_responses: stubbed? })
+  def self.kms(provider = nil)
+    self.client_cache(
+      provider,
+      Aws::KMS::Client
+    )
   end
 end

data/lib/geoengineer/utils/has_templates.rb

@@ -14,7 +14,7 @@ module HasTemplates
     module_clazz = "GeoEngineer::Templates::#{clazz_name}"
     return Object.const_get(module_clazz) if Object.const_defined? module_clazz
 
-    throw "undefined template '#{type}' for '#{clazz_name}' or 'GeoEngineer::#{clazz_name}'"
+    throw "undefined template '#{type}' for '#{clazz_name}' or '#{module_clazz}'"
   end
 
   def from_template(type, name, parameters = {}, &block)

data/lib/geoengineer/version.rb

@@ -1,3 +1,3 @@
 module GeoEngineer
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/spec/environment_spec.rb

@@ -52,7 +52,7 @@ describe GeoEngineer::Environment do
   describe '#codifies_resources' do
     it 'should return both codified and uncodified resources' do
       class GeoEngineer::Resources::CodifiedResource < GeoEngineer::Resource
-        def self._fetch_remote_resources
+        def self._fetch_remote_resources(provider)
           [{ _geo_id: "geo_id1" }, { _geo_id: "geo_id2" }]
         end
       end

data/spec/resource_spec.rb

@@ -1,7 +1,7 @@
 require_relative './spec_helper'
 
 class GeoEngineer::RemoteResources < GeoEngineer::Resource
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     [{ _geo_id: "geo_id1" }, { _geo_id: "geo_id2" }, { _geo_id: "geo_id2" }]
   end
 end
@@ -88,23 +88,36 @@ describe GeoEngineer::Resource do
   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
+    class GeoEngineer::FetchableResources < GeoEngineer::Resource
+      def self._fetch_remote_resources(provider)
+        [{ _geo_id: "geoid #{provider.id}" }]
       end
+    end
+
+    it 'should return a list of resources' do
+      provider = GeoEngineer::Provider.new("prov_1")
+      resources = GeoEngineer::FetchableResources.fetch_remote_resources(provider)
+      expect(resources.length).to eq 1
+      expect(resources[0]._geo_id).to eq "geoid prov_1"
+    end
+
+    it 'should retrieve different resources for different providers' do
+      provider1 = GeoEngineer::Provider.new("prov_1")
+      resources = GeoEngineer::FetchableResources.fetch_remote_resources(provider1)
+      expect(resources.length).to eq 1
+      expect(resources[0]._geo_id).to eq "geoid prov_1"
 
-      resources = GeoEngineer::FetchableResources.fetch_remote_resources()
+      provider2 = GeoEngineer::Provider.new("prov_2")
+      resources = GeoEngineer::FetchableResources.fetch_remote_resources(provider2)
       expect(resources.length).to eq 1
-      expect(resources[0]._geo_id).to eq "geoid"
+      expect(resources[0]._geo_id).to eq "geoid prov_2"
     end
   end
 
   describe '#_resources_to_ignore' do
     it 'lets you ignore certain resources' do
       class GeoEngineer::IgnorableResources < GeoEngineer::Resource
-        def self._fetch_remote_resources
+        def self._fetch_remote_resources(provider)
           [{ _geo_id: "geoid1" }, { _geo_id: "geoid2" }]
         end
 
@@ -113,7 +126,8 @@ describe GeoEngineer::Resource do
         end
       end
 
-      resources = GeoEngineer::IgnorableResources.fetch_remote_resources()
+      resources = GeoEngineer::IgnorableResources
+                  .fetch_remote_resources(GeoEngineer::Provider.new('aws'))
       expect(resources.length).to eq 1
       expect(resources[0]._geo_id).to eq "geoid2"
     end

data/spec/resources/aws_alb_listener_rule_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsAlbListenerRule do
+  let(:alb_client) { AwsClients.alb }
+
+  common_resource_tests(described_class, described_class.type_from_class_name)
+
+  before { alb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      alb_client.stub_responses(
+        :describe_load_balancers,
+        {
+          load_balancers: [{ load_balancer_arn: "foo/bar-baz" }]
+        }
+      )
+      alb_client.stub_responses(
+        :describe_listeners,
+        {
+          listeners: [
+            {
+              load_balancer_arn: "foo/bar-baz",
+              listener_arn: "listener/foo/bar-baz",
+              port: 443
+            }
+          ]
+        }
+      )
+      alb_client.stub_responses(
+        :describe_rules,
+        {
+          rules: [
+            {
+              rule_arn: "rule/foo/bar-baz",
+              priority: "69"
+            }
+          ]
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsAlbListenerRule._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_alb_listener_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsAlbListener do
+  let(:alb_client) { AwsClients.alb }
+
+  common_resource_tests(described_class, described_class.type_from_class_name)
+
+  before { alb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      alb_client.stub_responses(
+        :describe_load_balancers,
+        {
+          load_balancers: [{ load_balancer_arn: "foo/bar-baz" }]
+        }
+      )
+      alb_client.stub_responses(
+        :describe_listeners,
+        {
+          listeners: [
+            {
+              load_balancer_arn: "foo/bar-baz",
+              port: 443
+            }
+          ]
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsAlbListener._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_alb_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsAlb do
+  let(:alb_client) { AwsClients.alb }
+
+  common_resource_tests(described_class, described_class.type_from_class_name)
+
+  before { alb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      alb_client.stub_responses(
+        :describe_load_balancers,
+        {
+          load_balancers: [{ load_balancer_arn: "foo/bar-baz" }]
+        }
+      )
+      alb_client.stub_responses(
+        :describe_tags,
+        {
+          tag_descriptions: [
+            {
+              resource_arn: "foo/bar-baz",
+              tags: [{ key: "Name", value: "foo/bar-baz" }]
+            }
+          ]
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsAlb._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 1
+    end
+  end
+end

data/spec/resources/aws_alb_target_group_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe GeoEngineer::Resources::AwsAlbTargetGroup do
+  let(:alb_client) { AwsClients.alb }
+
+  common_resource_tests(described_class, described_class.type_from_class_name)
+
+  before { alb_client.setup_stubbing }
+
+  describe "#_fetch_remote_resources" do
+    it 'should create list of hashes from returned AWS SDK' do
+      alb_client.stub_responses(
+        :describe_target_groups,
+        {
+          target_groups: [
+            {
+              target_group_arn: "targetgroup/foo/bar-baz",
+              port: 443,
+              protocol: "HTTPS",
+              vpc_id: "vpc-1"
+            },
+            {
+              target_group_arn: "targetgroup/foo/test-test",
+              port: 80,
+              protocol: "HTTP",
+              vpc_id: "vpc-1"
+            }
+          ]
+        }
+      )
+      remote_resources = GeoEngineer::Resources::AwsAlbTargetGroup._fetch_remote_resources(nil)
+      expect(remote_resources.length).to eq 2
+    end
+  end
+end