skywriter 1.0.0

data/spec/skywriter/resource_property_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Skywriter::ResourceProperty do
+  let(:resource_property_class) do
+    Class.new(Skywriter::ResourceProperty) do
+      property :FooBar
+      property :BazQux
+    end
+  end
+
+  let(:resource_class) do
+    class Skywriter::Resource::TestResource
+      include Skywriter::Resource
+
+      property :FooBar
+    end
+    Skywriter::Resource::TestResource
+  end
+
+
+  describe "#to_json" do
+    context "with pointer in resource property" do
+      let(:resource) do
+        resource_class.new("resource")
+      end
+
+      subject { resource_property_class.new(foo_bar: resource.as_pointer) }
+
+      it "doesn't explode with in resource property in a resource" do
+        expect { subject.to_json }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#as_json" do
+    context "with missing properties" do
+      subject { resource_property_class.new(foo_bar: '1').as_json }
+
+      it "includes present properties" do
+        expect(subject).to have_key('FooBar')
+      end
+
+      it "excludes missing properties" do
+        expect(subject).to_not have_key('BazQux')
+      end
+    end
+
+    context "with nil properties" do
+      subject { resource_property_class.new(foo_bar: '1', baz_qux: nil).as_json }
+
+      it "includes present properties" do
+        expect(subject).to have_key('FooBar')
+      end
+
+      it "excludes nil properties" do
+        expect(subject).to_not have_key('BazQux')
+      end
+    end
+
+    context "with snake case symbol property names" do
+      subject { resource_property_class.new(foo_bar: 'baz').as_json }
+
+      it "sets value" do
+        expect(subject).to have_key('FooBar')
+      end
+    end
+
+    context "with snake case string property names" do
+      subject { resource_property_class.new('foo_bar' => 'baz').as_json }
+
+      it "sets value" do
+        expect(subject).to have_key('FooBar')
+      end
+    end
+
+    context "with CamelCase symbol property names" do
+      subject { resource_property_class.new(FooBar: 'baz').as_json }
+
+      it "sets value" do
+        expect(subject).to have_key('FooBar')
+      end
+    end
+
+    context "with CamelCase string property names" do
+      subject { resource_property_class.new('FooBar' => 'baz').as_json }
+
+      it "sets value" do
+        expect(subject).to have_key('FooBar')
+      end
+    end
+  end
+end
+
+describe "The implementation" do
+  [
+    Skywriter::ResourceProperty::AutoScaling::BlockDeviceMapping,
+    Skywriter::ResourceProperty::AutoScaling::EBSBlockDevice,
+    Skywriter::ResourceProperty::AutoScaling::NotificationConfiguration,
+    Skywriter::ResourceProperty::AutoScaling::Tag,
+    Skywriter::ResourceProperty::AutoScaling::EBSBlockDevice,
+    Skywriter::ResourceProperty::CloudFront::CacheBehavior,
+    Skywriter::ResourceProperty::CloudFront::ForwardedValue,
+    Skywriter::ResourceProperty::CloudFront::CustomOrigin,
+    Skywriter::ResourceProperty::CloudFront::DefaultCacheBehavior,
+    Skywriter::ResourceProperty::CloudFront::DistributionConfig,
+    Skywriter::ResourceProperty::CloudFront::Logging,
+    Skywriter::ResourceProperty::CloudFront::Origin,
+    Skywriter::ResourceProperty::CloudFront::S3Origin,
+    Skywriter::ResourceProperty::CloudWatch::MetricDimension,
+    Skywriter::ResourceProperty::DynamoDB::AttributeDefinition,
+    Skywriter::ResourceProperty::DynamoDB::GlobalSecondaryIndex,
+    Skywriter::ResourceProperty::DynamoDB::KeySchema,
+    Skywriter::ResourceProperty::DynamoDB::LocalSecondaryIndex,
+    Skywriter::ResourceProperty::DynamoDB::Projection,
+    Skywriter::ResourceProperty::DynamoDB::ProvisionedThroughput,
+    Skywriter::ResourceProperty::EC2::BlockDeviceMapping,
+    Skywriter::ResourceProperty::EC2::EBSBlockDevice,
+    Skywriter::ResourceProperty::EC2::ICMP,
+    Skywriter::ResourceProperty::EC2::MountPoint,
+    Skywriter::ResourceProperty::EC2::NetworkInterface,
+    Skywriter::ResourceProperty::EC2::NetworkInterfaceAssociation,
+    Skywriter::ResourceProperty::EC2::NetworkInterfaceAttachment,
+    Skywriter::ResourceProperty::EC2::NetworkInterfaceGroupItem,
+    Skywriter::ResourceProperty::EC2::NetworkInterfacePrivateIPSpecification,
+    Skywriter::ResourceProperty::EC2::PortRange,
+    Skywriter::ResourceProperty::EC2::SecurityGroupRule,
+    Skywriter::Resource::EC2::SecurityGroupEgress,
+    Skywriter::Resource::EC2::SecurityGroupIngress,
+    Skywriter::ResourceProperty::EC2::Tag,
+    Skywriter::ResourceProperty::ElasticBeanstalk::EnvironmentTier,
+    Skywriter::ResourceProperty::ElasticBeanstalk::OptionSetting,
+    Skywriter::ResourceProperty::ElasticBeanstalk::SourceBundle,
+    Skywriter::ResourceProperty::ElasticBeanstalk::SourceConfiguration,
+    Skywriter::ResourceProperty::ElasticLoadBalancing::AppCookieStickinessPolicy,
+    Skywriter::ResourceProperty::ElasticLoadBalancing::HealthCheck,
+    Skywriter::ResourceProperty::ElasticLoadBalancing::LBCookieStickinessPolicy,
+    Skywriter::ResourceProperty::ElasticLoadBalancing::Listener,
+    Skywriter::ResourceProperty::ElasticLoadBalancing::Policy,
+    Skywriter::ResourceProperty::Redshift::Parameter,
+    Skywriter::ResourceProperty::CloudFormation::ResourceTag,
+    Skywriter::ResourceProperty::RDS::SecurityGroupRule,
+    Skywriter::ResourceProperty::Route53::AliasTarget,
+    Skywriter::ResourceProperty::S3::WebsiteConfiguration,
+    Skywriter::ResourceProperty::SNS::Subscription,
+    Skywriter::ResourceProperty::SQS::RedrivePolicy,
+  ].each do |klass|
+    context "of #{klass.name}" do
+      it "inherits from resource property" do
+        expect(klass.new).to be_a(Skywriter::ResourceProperty)
+      end
+    end
+  end
+end

data/spec/skywriter/resource_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+describe Skywriter::Resource do
+  let(:resource_class) do
+    class Skywriter::Resource::TestResource
+      include Skywriter::Resource
+
+      property :FooBar
+    end
+    Skywriter::Resource::TestResource
+  end
+
+  let(:child_class) do
+    class ChildClass < resource_class; end
+    ChildClass
+  end
+
+
+  describe "#as_json" do
+    it "serializes literal property values specified with snake case symbols" do
+      resource = resource_class.new('resource name', foo_bar: 'value')
+
+      expect(resource.as_json['resource name']['Properties']['FooBar']).to eq("value")
+    end
+
+    it "serializes literal property values specified with snake case strings" do
+      resource = resource_class.new('resource name', 'foo_bar' => 'value')
+
+      expect(resource.as_json['resource name']['Properties']['FooBar']).to eq("value")
+    end
+
+    it "serializes literal property values specified with CamelCase symbols" do
+      resource = resource_class.new('resource name', FooBar: 'value')
+
+      expect(resource.as_json['resource name']['Properties']['FooBar']).to eq("value")
+    end
+
+    it "serializes literal property values specified with CamelCase strings" do
+      resource = resource_class.new('resource name', 'FooBar' => 'value')
+
+      expect(resource.as_json['resource name']['Properties']['FooBar']).to eq("value")
+    end
+
+    it "sets type" do
+      resource = resource_class.new('resource name', foo_bar: 'value')
+
+      expect(resource.as_json['resource name']['Type']).to eq("AWS::TestResource")
+    end
+
+    it "sets type correctly in child classes" do
+      resource = child_class.new('resource name', foo_bar: 'value')
+
+      expect(resource.as_json['resource name']['Type']).to eq("AWS::TestResource")
+    end
+
+    it "sets additional dependencies" do
+      resource = resource_class.new('resource name', additional_dependencies: 'value')
+
+      expect(resource.as_json['resource name']['DependsOn']).to include('value')
+    end
+
+    it "sets depends on key if pointer passed" do
+      reference = resource_class.new('reference')
+      resource = resource_class.new('resource name', foo_bar: reference.as_pointer)
+
+      expect(resource.as_json['resource name']['DependsOn']).to include('reference')
+    end
+
+    it "merges magical and additional depedencies" do
+      reference = resource_class.new('reference')
+      resource = resource_class.new('resource name', foo_bar: reference.as_pointer, additional_dependencies: ['depends on'])
+
+      expect(resource.as_json['resource name']['DependsOn']).to include('reference')
+      expect(resource.as_json['resource name']['DependsOn']).to include('depends on')
+    end
+
+    it "removes duplicate depedencies" do
+      reference = resource_class.new('reference')
+      resource = resource_class.new('resource name', foo_bar: reference.as_pointer, additional_dependencies: ['reference', 'reference'])
+
+      expect(resource.as_json['resource name']['DependsOn']).to eq(['reference'])
+    end
+
+    it "creates a DeletionPolicy key" do
+      resource = resource_class.new('resource name', foo_bar: 'x', deletion_policy: 'Retain')
+
+      expect(resource.as_json['resource name']['DeletionPolicy']).to eq('Retain')
+    end
+
+    it "creates a Metadata key" do
+      resource = resource_class.new('resource name', foo_bar: 'x', metadata: { foo: 'bar', baz: 'qux' })
+
+      expect(resource.as_json['resource name']['Metadata']).to eq(foo: 'bar', baz: 'qux')
+    end
+
+    it "creates a UpdatePolicy key" do
+      resource = resource_class.new(
+        'resource name',
+        foo_bar: 'x',
+        update_policy: {
+          AutoScalingRollingUpdate: {
+            MinInstancesInService: "1",
+            MaxBatchSize: "1",
+            PauseTime: "PT12M5S"
+          }
+        },
+      )
+
+      expect(resource.as_json['resource name']['UpdatePolicy']).to eq(
+        AutoScalingRollingUpdate: {
+          MinInstancesInService: "1",
+          MaxBatchSize: "1",
+          PauseTime: "PT12M5S"
+        }
+      )
+    end
+  end
+
+  describe "#register_dependency" do
+    it "adds logical name to dependency list" do
+      resource = resource_class.new('resource')
+      resource.register_dependency(double(logical_name: 'logical name'))
+
+      expect(resource.as_json['resource']['DependsOn']).to include('logical name')
+    end
+  end
+
+  describe "#as_pointer" do
+    context "with no args" do
+      subject { resource_class.new('resource name').as_pointer }
+
+      it "returns a reference" do
+        expect(subject).to be_a(Skywriter::Resource::RefPointer)
+      end
+    end
+
+    context "when asked for a ref" do
+      subject { resource_class.new('resource name').as_pointer(with: :ref) }
+
+      it "returns a logical name" do
+        expect(subject).to be_a(Skywriter::Resource::RefPointer)
+      end
+    end
+
+    context "when asked for a logical name" do
+      subject { resource_class.new('resource name').as_pointer(with: :logical_name) }
+
+      it "returns a logical name" do
+        expect(subject).to be_a(Skywriter::Resource::LogicalNamePointer)
+      end
+    end
+  end
+end
+
+describe "The implementation" do
+  [
+    Skywriter::Resource::AutoScaling::AutoScalingGroup,
+    Skywriter::Resource::AutoScaling::LaunchConfiguration,
+    Skywriter::Resource::AutoScaling::ScalingPolicy,
+    Skywriter::Resource::AutoScaling::ScheduledAction,
+    Skywriter::Resource::AutoScaling::Trigger,
+    Skywriter::Resource::CloudFormation::Stack,
+    Skywriter::Resource::CloudFormation::WaitConditionHandle,
+    Skywriter::Resource::CloudFormation::WaitCondition,
+    Skywriter::Resource::CloudFront::Distribution,
+    Skywriter::Resource::CloudWatch::Alarm,
+    Skywriter::Resource::DynamoDB::Table,
+    Skywriter::Resource::EC2::CustomerGateway,
+    Skywriter::Resource::EC2::DHCPOptions,
+    Skywriter::Resource::EC2::EIPAssociation,
+    Skywriter::Resource::EC2::EIP,
+    Skywriter::Resource::EC2::Instance,
+    Skywriter::Resource::EC2::InternetGateway,
+    Skywriter::Resource::EC2::NetworkAclEntry,
+    Skywriter::Resource::EC2::NetworkAcl,
+    Skywriter::Resource::EC2::NetworkInterfaceAttachment,
+    Skywriter::Resource::EC2::NetworkInterface,
+    Skywriter::Resource::EC2::Route,
+    Skywriter::Resource::EC2::RouteTable,
+    Skywriter::Resource::EC2::SecurityGroup,
+    Skywriter::Resource::EC2::SubnetNetworkAclAssociation,
+    Skywriter::Resource::EC2::SubnetRouteTableAssociation,
+    Skywriter::Resource::EC2::Subnet,
+    Skywriter::Resource::EC2::VolumeAttachment,
+    Skywriter::Resource::EC2::Volume,
+    Skywriter::Resource::EC2::VPCDHCPOptionsAssociation,
+    Skywriter::Resource::EC2::VPCGatewayAttachment,
+    Skywriter::Resource::EC2::VPC,
+    Skywriter::Resource::EC2::VPNConnectionRoute,
+    Skywriter::Resource::EC2::VPNConnection,
+    Skywriter::Resource::EC2::VPNGatewayRoutePropagation,
+    Skywriter::Resource::EC2::VPNGateway,
+    Skywriter::Resource::ElastiCache::CacheCluster,
+    Skywriter::Resource::ElastiCache::ParameterGroup,
+    Skywriter::Resource::ElastiCache::SecurityGroup,
+    Skywriter::Resource::ElastiCache::SecurityGroupIngress,
+    Skywriter::Resource::ElastiCache::SubnetGroup,
+    Skywriter::Resource::ElasticBeanstalk::Application,
+    Skywriter::Resource::ElasticBeanstalk::ApplicationVersion,
+    Skywriter::Resource::ElasticBeanstalk::ConfigurationTemplate,
+    Skywriter::Resource::ElasticBeanstalk::Environment,
+    Skywriter::Resource::ElasticLoadBalancing::LoadBalancer,
+    Skywriter::Resource::IAM::AccessKey,
+    Skywriter::Resource::IAM::Group,
+    Skywriter::Resource::IAM::InstanceProfile,
+    Skywriter::Resource::IAM::Policy,
+    Skywriter::Resource::IAM::Role,
+    Skywriter::Resource::IAM::User,
+    Skywriter::Resource::IAM::UserToGroupAddition,
+    Skywriter::Resource::Redshift::Cluster,
+    Skywriter::Resource::Redshift::ClusterParameterGroup,
+    Skywriter::Resource::Redshift::ClusterSecurityGroup,
+    Skywriter::Resource::Redshift::ClusterSecurityGroupIngress,
+    Skywriter::Resource::Redshift::ClusterSubnetGroup,
+    Skywriter::Resource::RDS::DBInstance,
+    Skywriter::Resource::RDS::DBParameterGroup,
+    Skywriter::Resource::RDS::DBSubnetGroup,
+    Skywriter::Resource::RDS::DBSecurityGroup,
+    Skywriter::Resource::RDS::DBSecurityGroupIngress,
+    Skywriter::Resource::Route53::RecordSet,
+    Skywriter::Resource::Route53::RecordSetGroup,
+    Skywriter::Resource::S3::Bucket,
+    Skywriter::Resource::S3::BucketPolicy,
+    Skywriter::Resource::SDB::Domain,
+    Skywriter::Resource::SNS::TopicPolicy,
+    Skywriter::Resource::SNS::Topic,
+    Skywriter::Resource::SQS::Queue,
+    Skywriter::Resource::SQS::QueuePolicy
+  ].each do |klass|
+    context "of #{klass.name}" do
+      it "is a resource" do
+        expect(klass.new('name')).to be_a(Skywriter::Resource)
+      end
+    end
+  end
+end

data/spec/skywriter/template_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Skywriter::Template do
+  describe "#to_json" do
+    it "doesn't explode" do
+      expect { Skywriter::Template.new.to_json }.to_not raise_error
+    end
+    
+  end
+
+  describe "#as_json" do
+    context "with an empty object" do
+      let(:template) { Skywriter::Template.new }
+      let(:hash) { template.as_json }
+
+      it "uses default FormatVersion value" do
+        expect(hash['FormatVersion']).to eq('2010-09-09')
+      end
+
+      it "does not have a Description key" do
+        expect(hash).to_not have_key('Description')
+      end
+
+      it "has a Parameters key" do
+        expect(hash).to have_key('Parameters')
+      end
+
+      it "has a Mappings key" do
+        expect(hash).to have_key('Mappings')
+      end
+
+      it "has a Conditions key" do
+        expect(hash).to have_key('Conditions')
+      end
+
+      it "has a Resources key" do
+        expect(hash).to have_key('Resources')
+      end
+
+      it "has a Outputs key" do
+        expect(hash).to have_key('Outputs')
+      end
+    end
+
+    context "with format version" do
+      let(:template) { Skywriter::Template.new(:format_version => 'foo') }
+      let(:hash) { template.as_json }
+
+      it "has the passed FormatVersion value" do
+        expect(hash['FormatVersion']).to eq('foo')
+      end
+    end
+
+    context "with description" do
+      let(:template) { Skywriter::Template.new(:description => 'foo') }
+      let(:hash) { template.as_json }
+
+      it "has a Description key" do
+        expect(hash).to have_key('Description')
+      end
+    end
+
+    context "with array of Resources" do
+      let(:resource) do
+        double("Resource", as_json: {"Resource" => {}})
+      end
+
+      let(:other_resource) do
+        double("OtherResource", as_json: {"OtherResource" => {}})
+      end
+
+      let(:template) do
+        Skywriter::Template.new(
+          resources: [resource, other_resource]
+        )
+      end
+
+      let(:hash) { template.as_json }
+
+      it "includes resources" do
+        expect(hash['Resources']).to have_key('Resource')
+        expect(hash['Resources']).to have_key('OtherResource')
+      end
+    end
+
+    context "with resources hash" do
+      let(:template) do
+        Skywriter::Template.new(
+          resources: {"foo" => "bar"}
+        )
+      end
+
+      it "includes resources hash" do
+        expect(template.as_json['Resources']).to eq("foo" => "bar")
+      end
+    end
+
+    context "with snake case symbol key name" do
+      let(:template) do
+        Skywriter::Template.new(
+          resources: {"foo" => "bar"}
+        )
+      end
+
+      it "sets value" do
+        expect(template.as_json['Resources']).to eq("foo" => "bar")
+      end
+    end
+
+    context "with snake case string key name" do
+      let(:template) do
+        Skywriter::Template.new(
+          'resources' => {"foo" => "bar"}
+        )
+      end
+
+      it "sets value" do
+        expect(template.as_json['Resources']).to eq("foo" => "bar")
+      end
+    end
+
+    context "with CameCase symbol key name" do
+      let(:template) do
+        Skywriter::Template.new(
+          Resources: {"foo" => "bar"}
+        )
+      end
+
+      it "sets value" do
+        expect(template.as_json['Resources']).to eq("foo" => "bar")
+      end
+    end
+
+    context "with CamelCase string key name" do
+      let(:template) do
+        Skywriter::Template.new(
+          'Resources' => {"foo" => "bar"}
+        )
+      end
+
+      it "sets value" do
+        expect(template.as_json['Resources']).to eq("foo" => "bar")
+      end
+    end
+  end
+
+  describe "#merge" do
+    let(:resource) do
+      double("Resource", as_json: {'foo' => 'bar'})
+    end
+
+    let(:template) do
+      Skywriter::Template.new(
+        parameters: {'foo' => 'bar'},
+        mappings: {'foo' => 'bar'},
+        conditions: {'foo' => 'bar'},
+        resources: [resource],
+        outputs: {'foo' => 'bar'},
+      )
+    end
+
+    context "with another template containing conflicting values" do
+      let(:other_template) { Skywriter::Template.new(format_version: 'other format version') }
+
+      it "raises a MergeError" do
+        expect { template.merge(other_template) }.to raise_error(Skywriter::Template::MergeError)
+      end
+    end
+
+    context "with another template containing disjoint values" do
+      let(:other_template) { Skywriter::Template.new(description: 'description') }
+
+      it "sets the value on returned template" do
+        expect(template.merge(other_template).description).to eq('description')
+      end
+    end
+
+    # Disjoint
+    #
+    context "where the values of 'other' are disjoint" do
+      let(:disjoint_resource) do
+        double("OtherResource", as_json: {'baz' => 'qux'})
+      end
+
+      let(:disjoint_template) do
+        Skywriter::Template.new(
+          parameters: {'baz' => 'qux'},
+          mappings: {'baz' => 'qux'},
+          conditions: {'baz' => 'qux'},
+          resources: [disjoint_resource],
+          outputs: {'baz' => 'qux'},
+        )
+      end
+
+      subject { template.merge(disjoint_template) }
+
+      ['Parameters', 'Mappings', 'Conditions', 'Resources', 'Outputs'].each do |meth|
+        it "sets value of #{meth} to 'other' merged into 'self'" do
+          disjoint_template.as_json[meth].each_key do |other_key|
+            expect(subject.as_json[meth]).to have_key(other_key)
+          end
+
+          template.as_json[meth].each_key do |template_key|
+            expect(subject.as_json[meth]).to have_key(template_key)
+          end
+        end
+      end
+    end
+
+    # Duplicate
+    #
+    context "where the values of 'other' are duplicated" do
+      subject { template.merge(template) }
+
+      [:parameters, :mappings, :conditions, :resources, :outputs].each do |meth|
+        it "sets value of #{meth} to value from 'self'" do
+          template.send(meth).each_key do |other_key|
+            expect(subject.send(meth)).to have_key(other_key)
+          end
+        end
+      end
+    end
+
+    # Conflicting
+    #
+    context "where the values of 'other' are conflicting" do
+      let(:conflicting_resource) do
+        double("ConflictingResource", as_json: {'foo' => 'not bar'})
+      end
+
+      let(:conflicting_template) do
+        Skywriter::Template.new(
+          parameters: {'foo' => 'not bar'},
+          mappings: {'foo' => 'not bar'},
+          conditions: {'foo' => 'not bar'},
+          resources: [conflicting_resource],
+          outputs: {'foo' => 'not bar'},
+        )
+      end
+
+      it "raises an exception" do
+        expect { template.merge(conflicting_template) }.to raise_error(Skywriter::Template::MergeError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'pry'
+
+require 'skywriter'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end