geoengineer 0.1.0 → 0.1.1

data/lib/geoengineer/utils/has_projects.rb

@@ -0,0 +1,21 @@
+########################################################################
+# HasProjects provides methods for a class to contain and query a set of projects
+########################################################################
+module HasProjects
+  def projects
+    @_projects ||= {}
+  end
+
+  # Factory for creating projects
+  def create_project(org, name, &block)
+    # do not add the project a second time
+    repository = "#{org}/#{name}"
+    return projects[repository] if projects.key?(repository)
+
+    GeoEngineer::Project.new(org, name, self, &block)
+  end
+
+  def all_project_resources
+    projects.values.map(&:all_resources).flatten
+  end
+end

data/lib/geoengineer/utils/has_resources.rb

@@ -21,9 +21,10 @@ module HasResources
     @_resources
   end
 
-  # Overridden By Project and Environment
+  # Overridden By Template, Project and Environment,
+  # requires explicit override to avoid easy mistakes
   def all_resources
-    resources
+    raise NotImplementedError, "Including class must override this method"
   end
 
   def find_resource(type, id)
@@ -37,8 +38,9 @@ module HasResources
     find_resource(type, name)
   end
 
-  def resources_grouped_by
-    all_resources.each_with_object({}) do |r, c|
+  # Returns: { value1: [ ], value2: [ ] }
+  def resources_grouped_by(resources_to_group = all_resources)
+    resources_to_group.each_with_object({}) do |r, c|
       value = yield r
       c[value] ||= []
       c[value] << r
@@ -46,6 +48,17 @@ module HasResources
     end
   end
 
+  # Returns: { type1: { value1: [ ] }, type2: { value2: [ ] } }
+  def resources_of_type_grouped_by(&block)
+    grouped = resources_grouped_by(all_resources, &:type)
+
+    grouped_arr = grouped.map do |type, grouped_resources|
+      [type, resources_grouped_by(grouped_resources, &block)]
+    end
+
+    grouped_arr.to_h
+  end
+
   def resources_of_type(type)
     all_resources.select { |r| r.type == type }
   end

data/lib/geoengineer/utils/has_templates.rb

@@ -0,0 +1,31 @@
+########################################################################
+# HasTemplates provides methods for a class to contain and query a set of templates
+########################################################################
+module HasTemplates
+  def templates
+    @_templates ||= {}
+  end
+
+  # Templating Methods
+  def find_template(type)
+    clazz_name = type.split('_').collect(&:capitalize).join
+    return Object.const_get(clazz_name) if Object.const_defined? clazz_name
+
+    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}'"
+  end
+
+  def from_template(type, name, parameters = {}, &block)
+    throw "Template '#{name}' already defined" if templates[name]
+    clazz = find_template(type)
+    template = clazz.new(name, self, parameters)
+    template.instance_exec(*template.template_resources, &block) if block_given?
+    templates[name] = template
+  end
+
+  def all_template_resources
+    templates.values.map(&:all_resources).flatten
+  end
+end

data/lib/geoengineer/utils/has_validations.rb

@@ -49,9 +49,24 @@ module HasValidations
   # Validates CIDR block format
   # Returns error when argument fails validation
   def validate_cidr_block(cidr_block)
-    parsed_cidr = NetAddr::CIDR.create(cidr_block)
-    return [parsed_cidr, nil]
+    return if NetAddr::CIDR.create(cidr_block)
   rescue NetAddr::ValidationError
-    return [nil, "Bad cidr block \"#{cidr_block}\" #{for_resource}"]
+    return "Bad cidr block \"#{cidr_block}\" #{for_resource}"
+  end
+
+  # Validates that at least one of the specified attributes is present
+  def validate_at_least_one_present(attributes)
+    errs = []
+    present = attributes.select { |attribute| !self[attribute].nil? }.count
+    errs << "At least one of #{attributes.join(', ')} must be defined" unless present.positive?
+    errs
+  end
+
+  # Validates that ONLY one of the specified attributes is present
+  def validate_only_one_present(attributes)
+    errs = []
+    present = attributes.select { |attribute| !self[attribute].nil? }.count
+    errs << "Only one of #{attributes.join(', ')} can be defined" unless present == 1
+    errs
   end
 end

data/lib/geoengineer/version.rb

@@ -1,3 +1,3 @@
 module GeoEngineer
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

data/spec/environment_spec.rb

@@ -1,12 +1,15 @@
 require_relative './spec_helper'
 
-describe("GeoEngineer::Environment") do
+describe GeoEngineer::Environment do
+  let(:env) do
+    GeoEngineer::Environment.new("test") {
+      region "us-west-1"
+      account_id 1
+    }
+  end
+
   describe 'validations' do
     it 'should have unique terrform id' do
-      env = GeoEngineer::Environment.new("test") {
-        region "us-west-1"
-        account_id 1
-      }
       env.resource('type', 'id1') {
         _terraform_id "tid"
         _geo_id 'gid1'
@@ -20,10 +23,6 @@ describe("GeoEngineer::Environment") do
     end
 
     it 'should have unique geo_id' do
-      env = GeoEngineer::Environment.new("test") {
-        region "us-west-1"
-        account_id 1
-      }
       env.resource('type', 'id1') {
         _terraform_id "tid1"
         _geo_id 'gid'
@@ -37,10 +36,6 @@ describe("GeoEngineer::Environment") do
     end
 
     it 'should have unique type and ids' do
-      env = GeoEngineer::Environment.new("test") {
-        region "us-west-1"
-        account_id 1
-      }
       env.resource('type', 'id1') {
         _terraform_id "tid1"
         _geo_id 'gid1'
@@ -62,10 +57,10 @@ describe("GeoEngineer::Environment") do
         end
       end
 
-      env = GeoEngineer::Environment.new("test")
       env.resource('codified_resource', 'id1') {
         _terraform_id "geo_id1"
       }
+
       expect(env.codified_resources('codified_resource').length).to eq 1
       expect(env.uncodified_resources('codified_resource').length).to eq 1
     end
@@ -73,7 +68,6 @@ describe("GeoEngineer::Environment") do
 
   describe '#to_terraform_state' do
     it 'should return state of resources' do
-      env = GeoEngineer::Environment.new("test")
       env.resource('type', 'id1') {
         _terraform_id "tid"
         _geo_id 'gid1'
@@ -85,7 +79,6 @@ describe("GeoEngineer::Environment") do
 
   describe '#to_terraform_json' do
     it 'should return terraform of all resources' do
-      env = GeoEngineer::Environment.new("test")
       env.resource('type', 'id1') {
         _terraform_id "tid"
         _geo_id 'gid1'
@@ -97,7 +90,6 @@ describe("GeoEngineer::Environment") do
 
   describe '#project' do
     it 'should create a project with this as environment' do
-      env = GeoEngineer::Environment.new("test")
       env.project("org", "name") {
         environments 'test'
       }
@@ -105,7 +97,6 @@ describe("GeoEngineer::Environment") do
     end
 
     it 'should only load projects in the environment' do
-      env = GeoEngineer::Environment.new("test")
       p0 = env.project("org", "0") {
         environments 'test'
       }
@@ -121,7 +112,6 @@ describe("GeoEngineer::Environment") do
 
   describe '#all_resources' do
     it 'should include local and project resources (if project in env)' do
-      env = GeoEngineer::Environment.new("test")
       env.resource('type', 'id0') { x 2 }
 
       p0 = env.project("org", "0") {
@@ -137,4 +127,35 @@ describe("GeoEngineer::Environment") do
       expect(env.all_resources.length).to eq 2
     end
   end
+
+  describe '::HasTemplates' do
+    let!(:example_template) do
+      class Example < GeoEngineer::Template
+        def initialize(name, parent, parameters = {})
+          super(name, parent, parameters)
+          resource('aws_vpc', 'example') {
+            cidr_block('10.123.0.0/16')
+          }
+        end
+      end
+    end
+
+    describe '#from_template' do
+      it 'allows environments to create resources from templates' do
+        expect {
+          env.from_template('example', 'example_template')
+        }.to_not raise_error
+      end
+
+      it 'includes template resources in #all_resources' do
+        env.from_template('example', 'example_template')
+        expect(env.all_resources.count).to eq(1)
+      end
+
+      it 'adds a reference to the environment on each resource created' do
+        env.from_template('example', 'example_template')
+        expect(env.all_resources.first.environment).to eq(env)
+      end
+    end
+  end
 end

data/spec/project_spec.rb

@@ -50,8 +50,8 @@ describe("GeoEngineer::Project") do
       project = GeoEngineer::Project.new('org', "project_name", nil)
       temp1 = project.from_template('in_module_template', 'in')
       temp2 = project.from_template('out_module_template', 'out')
-      expect(temp1.template_resources.length).to eq 0
-      expect(temp2.template_resources.length).to eq 2
+      expect(temp1.resources.length).to eq 0
+      expect(temp2.resources.length).to eq 2
     end
 
     it 'should error if the template is not found' do

data/spec/resource_spec.rb

@@ -1,13 +1,13 @@
 require_relative './spec_helper'
 
+class GeoEngineer::RemoteResources < GeoEngineer::Resource
+  def self._fetch_remote_resources
+    [{ _geo_id: "geo_id1" }, { _geo_id: "geo_id2" }, { _geo_id: "geo_id2" }]
+  end
+end
+
 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"
@@ -153,6 +153,87 @@ describe("GeoEngineer::Resource") do
     end
   end
 
+  describe '#validate_tag_merge' do
+    it 'should combine resource and project tags' do
+      project = GeoEngineer::Project.new('org', 'project_name', 'test') {
+        tags {
+          a  '1'
+        }
+      }
+      resource = project.resource('type', '1') {
+        tags {
+          d  '4'
+        }
+      }
+      resource.merge_project_tags
+      expect(resource.tags.attributes).to eq({ 'a' => '1', 'd' => '4' })
+    end
+
+    it 'should give priority to resource tags' do
+      project = GeoEngineer::Project.new('org', 'project_name', 'test') {
+        tags {
+          a  'project_value'
+        }
+      }
+      resource = project.resource('type', '1') {
+        tags {
+          a  'resource_value'
+        }
+      }
+      resource.merge_project_tags
+      expect(resource.tags.attributes).to eq({ 'a' => 'resource_value' })
+    end
+
+    it 'should return project tags if there are no resource tags' do
+      project = GeoEngineer::Project.new('org', 'project_name', 'test') {
+        tags {
+          a  '1'
+          b  '2'
+        }
+      }
+      resource = project.resource('type', '1') {}
+      resource.merge_project_tags
+      expect(resource.tags.attributes).to eq({ 'a' => '1', 'b' => '2' })
+    end
+
+    it 'should return resource tags if there are no project tags' do
+      project = GeoEngineer::Project.new('org', 'project_name', 'test') {}
+      resource = project.resource('type', '1') {
+        tags {
+          c  '3'
+          d  '4'
+        }
+      }
+      resource.merge_project_tags
+      expect(resource.tags.attributes).to eq({ 'c' => '3', 'd' => '4' })
+    end
+  end
+
+  describe '#reset' do
+    let(:subject) do
+      GeoEngineer::RemoteResources.new('resource', 'id') {
+        tags {
+          Name "foo"
+        }
+        _geo_id -> { tags['Name'] }
+      }
+    end
+
+    it 'resets lazily computed attributes' do
+      expect(subject._geo_id).to eq('foo')
+      subject.tags['Name'] = 'bar'
+      subject.reset
+      expect(subject._geo_id).to eq('bar')
+    end
+
+    it 'resets remote resource' do
+      expect(subject.remote_resource).to be_nil
+      subject.tags['Name'] = "geo_id1"
+      subject.reset
+      expect(subject.remote_resource).to_not be_nil
+    end
+  end
+
   describe 'class method' do
     describe('#type_from_class_name') do
       it 'should return resource' do

data/spec/resources/aws_customer_gateway_spec.rb

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

data/spec/resources/aws_eip_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsEip" do
+  let(:aws_client) { AwsClients.ec2 }
+
+  common_resource_tests(GeoEngineer::Resources::AwsEip, 'aws_eip')
+
+  describe '#_fetch_remote_resources' do
+    before do
+      aws_client.stub_responses(
+        :describe_addresses, {
+          addresses: [
+            { public_ip: '99.0.0.0', allocation_id: "eipalloc-xxxxxxxx" },
+            { public_ip: '99.0.0.1', allocation_id: "eipalloc-xxxxxxxy" }
+          ]
+        }
+      )
+    end
+
+    it 'should create an array of hashes from the AWS response' do
+      resources = GeoEngineer::Resources::AwsEip._fetch_remote_resources
+      expect(resources.count).to eql 2
+
+      test_eip = resources.first
+      expect(test_eip[:_terraform_id]).to eql "eipalloc-xxxxxxxx"
+      expect(test_eip[:_geo_id]).to eql "99.0.0.0"
+    end
+  end
+end

data/spec/resources/aws_iam_group_membership_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../spec_helper'
+
+describe "GeoEngineer::Resources::AwsIamGroupMembership" do
+  let(:aws_client) { AwsClients.iam }
+
+  let!(:iam_user) do
+    GeoEngineer::Resources::AwsIamUser.new('aws_iam_user', 'fake-iam-user') {
+      name 'fake-iam-user'
+    }
+  end
+
+  let!(:iam_group) do
+    GeoEngineer::Resources::AwsIamGroup.new('aws_iam_group', 'fake-iam-group') {
+      name 'fake-iam-group'
+    }
+  end
+
+  let(:iam_group_membership) do
+    group = iam_group
+    user = iam_user
+
+    GeoEngineer::Resources::AwsIamGroupMembership
+      .new('aws_iam_group_membership', 'fake-iam-group-membership') {
+        name 'fake-iam-group-membership'
+        _group group
+        users [user]
+      }
+  end
+
+  common_resource_tests(
+    GeoEngineer::Resources::AwsIamGroupMembership,
+    'aws_iam_group_membership',
+    false
+  )
+
+  before do
+    aws_client.stub_responses(
+      :list_groups, {
+        'groups': [
+          {
+            group_name: 'fake-iam-group',
+            path: '/',
+            arn: 'arn:aws:iam::aws:iam-group/xyv/FakeAwsARN',
+            create_date: Time.parse("2016-12-13 11:54:59 -0800"),
+            group_id: '12345'
+          }
+        ]
+      }
+    )
+
+    aws_client.stub_responses(
+      :get_group, {
+        'group': {
+          group_name: 'fake-iam-group',
+          path: '/',
+          arn: 'arn:aws:iam::aws:iam-group/xyv/FakeAwsARN',
+          create_date: Time.parse("2016-12-13 11:54:59 -0800"),
+          group_id: '12345'
+        },
+        'users': [
+          {
+            path: '/',
+            user_name: 'fake-iam-user',
+            user_id: '1234',
+            arn: 'arn:aws:iam::aws:iam-user/xyv/FakeAwsARN',
+            create_date: Time.parse("2016-12-14 11:54:59 -0800")
+          }
+        ]
+      }
+    )
+  end
+
+  describe '#remote_resource_params' do
+    it 'should create a hash of params for the remote resources' do
+      remote_resource_params = iam_group_membership.remote_resource_params
+
+      expect(remote_resource_params[:name]).to eql("fake-iam-group")
+      expect(remote_resource_params[:_terraform_id]).to eql("fake-iam-group-membership")
+      expect(remote_resource_params[:_geo_id]).to eql("fake-iam-group-membership")
+      expect(remote_resource_params[:users]).to eql(["fake-iam-user"])
+    end
+  end
+end