dumbwaiter 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d02466f683759df1f7d27af7a349ce83de12c41c
-  data.tar.gz: 5ecab858e33074f2788bbeff38b7c0851bb63599
+  metadata.gz: 94944ee58a46b0164e4f7937fcc3b066213f042c
+  data.tar.gz: 50cdfe19a328a832ff374dc68cbe50900e090b0e
 SHA512:
-  metadata.gz: d14fed084083d8192e0ea94905a1088260e74f297775ea8253327d613ba74ea83e846f5a621f76e406e5a522212720248adaa08b693a0634bcb3bf1f3c48923b
-  data.tar.gz: 77196fefac097ad52c90d365f64c3de61182f6f5f90913bd21cc2aac92cd5f6856c4aab9e6318bb55b0818b9b8c14b71bbd75a33f43d9c9c12360f6eba7e0743
+  metadata.gz: 0ca9bbc6e30aa1b6dee2a134d419c7180c5586979f83f7c633971de0800eb2f8e2966bb8252f13627b07e082ee5dcef1a95338b9f1359dff34adb90eea7ee9cd
+  data.tar.gz: fdedb2834345c6a697cf7ff8664473bfd494fc100a396afe13d8e4969c70f294da1269cd7965647da53a998146737e5faa44ff1271534061cba82a39123a2888

data/dumbwaiter.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "gem-release"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "faker"
 end

data/lib/dumbwaiter/app.rb

@@ -35,6 +35,14 @@ class Dumbwaiter::App
     opsworks_app.app_id
   end
 
+  def url
+    opsworks_app.app_source.url
+  end
+
+  def revision
+    opsworks_app.app_source.revision || "master"
+  end
+
   def deploy(revision = nil)
     deployment = as_deployment("deploy", args: {migrate: ["true"]})
     unless revision.nil?

data/lib/dumbwaiter/deployment.rb

@@ -2,13 +2,14 @@ require "dumbwaiter/deployment_custom_json"
 require "dumbwaiter/user_profile"
 
 class Dumbwaiter::Deployment
-  attr_reader :opsworks_deployment, :opsworks
+  attr_reader :stack, :opsworks_deployment, :opsworks
 
   def self.all(stack, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
-    opsworks.describe_deployments(stack_id: stack.id).deployments.map { |d| new(d, opsworks) }
+    opsworks.describe_deployments(stack_id: stack.id).deployments.map { |d| new(stack, d, opsworks) }
   end
 
-  def initialize(opsworks_deployment, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+  def initialize(stack, opsworks_deployment, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    @stack = stack
     @opsworks_deployment = opsworks_deployment
     @opsworks = opsworks
   end
@@ -30,23 +31,31 @@ class Dumbwaiter::Deployment
   end
 
   def user_name
-    if opsworks_deployment.iam_user_arn.nil?
-      "?"
+    if opsworks_deployment.iam_user_arn.nil? || user_profile.nil?
+      "OpsWorks"
     else
       user_profile.name
     end
   end
 
-  def git_ref
-    deployment_custom_json.git_ref
+  def revision
+    deployment_custom_json.revision || "#{app.revision}@{#{created_at}}"
   end
 
   def to_log
-    "#{created_at} - #{user_name} - #{command_name} - #{status} - #{git_ref}"
+    if command_name == "deploy"
+      "#{created_at} - #{user_name} - #{command_name} - #{status} - #{revision}"
+    else
+      "#{created_at} - #{user_name} - #{command_name} - #{status}"
+    end
   end
 
   protected
 
+  def app
+    Dumbwaiter::App.find_by_id(stack, opsworks_deployment.app_id, opsworks)
+  end
+
   def user_profile
     Dumbwaiter::UserProfile.find(opsworks_deployment.iam_user_arn, opsworks)
   end

data/lib/dumbwaiter/deployment_custom_json.rb

@@ -1,7 +1,7 @@
 require "hashie"
 require "json"
 
-class Dumbwaiter::DeploymentCustomJson < Hashie::Mash
+class Dumbwaiter::DeploymentCustomJson
   def self.from_json(json_string)
     new(JSON.parse(json_string))
   end
@@ -10,15 +10,19 @@ class Dumbwaiter::DeploymentCustomJson < Hashie::Mash
     {deploy: {name => {scm: {revision: ref}}}}
   end
 
+  def initialize(params)
+    @params = params
+  end
+
+  def params
+    Hashie::Mash.new(@params)
+  end
+
   def app_name
-    self.deploy.keys.first unless self.deploy.nil?
+    params.deploy.keys.first if params.deploy?
   end
 
-  def git_ref
-    if self.app_name.nil?
-      "HEAD"
-    else
-      self.deploy[self.app_name].scm.revision
-    end
+  def revision
+    params.deploy[app_name].scm.revision unless app_name.nil?
   end
 end

data/lib/dumbwaiter/mock.rb

@@ -0,0 +1,84 @@
+require "faker"
+
+class Dumbwaiter::Mock
+  attr_reader :stacks, :deployments, :apps, :layers, :instances, :user_profiles
+
+  def opsworks; self; end
+  def describe_stacks(*_); OpenStruct.new(stacks: stacks); end
+  def describe_deployments(*_); OpenStruct.new(deployments: deployments); end
+  def describe_apps(*_); OpenStruct.new(apps: apps); end
+  def describe_layers(*_); OpenStruct.new(layers: layers); end
+  def describe_instances(*_); OpenStruct.new(instances: instances); end
+  def describe_user_profiles(*_); OpenStruct.new(user_profiles: user_profiles); end
+
+  def clear
+    @stacks = []
+    @deployments = []
+    @apps = []
+    @layers = []
+    @instances = []
+    @user_profiles = []
+  end
+
+  def initialize
+    super
+    clear
+  end
+
+  def make_stack(id = make_id, name = Faker::Name.first_name, color = make_color)
+    stack = OpenStruct.new(stack_id: id, name: name, attributes: {"Color" => color})
+    stacks << stack
+    stack
+  end
+
+  def make_app(stack = make_stack, id = make_id, name = Faker::Name.first_name, url = Faker::Internet.url, revision = make_revision)
+    app = OpenStruct.new(stack_id: stack.stack_id, app_id: id, name: name, app_source: make_app_source(url, revision))
+    apps << app
+    app
+  end
+
+  def make_layer(stack = make_stack, id = make_id, shortname = Faker::Name.first_name.downcase)
+    layer = OpenStruct.new(stack_id: stack.stack_id, layer_id: id, shortname: shortname)
+    layers << layer
+    layer
+  end
+
+  def make_deployment(stack = make_stack, app = make_app, id = make_id, command_name = Faker::Name.first_name.downcase, status = Faker::Name.first_name, custom_json = "{}", at = Time.now.to_s, arn = Faker::Name.first_name, comment = Faker::Company.bs)
+    command = OpenStruct.new(name: command_name)
+    deployment = OpenStruct.new(stack_id: stack.stack_id, app_id: app.app_id, deployment_id: id, command: command, created_at: at, status: status, comment: comment, iam_user_arn: arn, custom_json: custom_json)
+    deployments << deployment
+    deployment
+  end
+
+  def make_instance(stack = make_stack, layer = make_layer, id = make_id)
+    instance = OpenStruct.new(layer_id: layer.layer_id, stack_id: stack.stack_id, instance_id: id)
+    instances << instance
+    instance
+  end
+
+  def make_user_profile(id = Faker::Name.last_name.downcase, name = Faker::Name.first_name)
+    user_profile = OpenStruct.new(aws_iam_arn: id, name: name)
+    user_profiles << user_profile
+    user_profile
+  end
+
+  protected
+
+  def make_app_source(url, revision)
+    OpenStruct.new(url: url, revision: revision)
+  end
+
+  def make_revision
+    "%06x" % (rand * 0xffffff)
+  end
+
+  def make_color
+    "rgb(#{rand(255)},#{rand(255)},#{rand(255)})"
+  end
+
+  def make_id
+    @id ||= 0
+    @id += 1
+    "taco-#{@id}"
+  end
+end

data/lib/dumbwaiter/version.rb

@@ -1,3 +1,3 @@
 module Dumbwaiter
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/dumbwaiter.rb

@@ -1,4 +1,2 @@
-module Dumbwaiter; end
-
-require "dumbwaiter/cli"
 require "dumbwaiter/version"
+require "dumbwaiter/cli"

data/spec/lib/dumbwaiter/app_spec.rb

@@ -1,17 +1,30 @@
 require "spec_helper"
 
 describe Dumbwaiter::App do
-  let(:fake_stack) { double(:stack, id: "pancakes") }
-  let(:fake_app) { double(:app, name: "goose", app_id: "amazing") }
-  let(:fake_apps) { double(:apps, apps: [fake_app]) }
-  let(:fake_opsworks) { double(:opsworks, describe_apps: fake_apps) }
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let(:fake_stack) { fake_opsworks.make_stack("pancakes") }
+  let!(:fake_app) { fake_opsworks.make_app(fake_stack, "amazing", "goose", "git@example.com:tacos/great.git") }
+  let(:real_stack) { Dumbwaiter::Stack.new(fake_stack, fake_opsworks) }
 
-  subject(:app) { Dumbwaiter::App.new(fake_stack, fake_app, fake_opsworks) }
+  subject(:app) { Dumbwaiter::App.new(real_stack, fake_app, fake_opsworks) }
 
-  its(:stack) { should == fake_stack }
-  its(:opsworks_app) { should == fake_app }
   its(:id) { should == "amazing" }
   its(:name) { should == "goose" }
+  its(:url) { should == "git@example.com:tacos/great.git" }
+
+  describe "#revision" do
+    context "when there is no revision specified" do
+      let(:fake_app) { fake_opsworks.make_app(fake_stack, "amazing", "goose", "git@example.com:tacos/great.git", nil) }
+
+      its(:revision) { should == "master" }
+    end
+
+    context "when a revision is specified" do
+      let(:fake_app) { fake_opsworks.make_app(fake_stack, "amazing", "goose", "git@example.com:tacos/great.git", "wat") }
+
+      its(:revision) { should == "wat" }
+    end
+  end
 
   describe "#deploy" do
     context "when no revision is specified" do
@@ -48,22 +61,22 @@ describe Dumbwaiter::App do
 
   describe ".all" do
     it "fetches all the apps" do
-      fake_opsworks.should_receive(:describe_apps).with(stack_id: "pancakes")
-      Dumbwaiter::App.all(fake_stack, fake_opsworks).should have(1).app
+      fake_opsworks.should_receive(:describe_apps).with(stack_id: "pancakes").and_call_original
+      Dumbwaiter::App.all(real_stack, fake_opsworks).should have(1).app
     end
   end
 
   describe ".find" do
     context "when the app exists" do
       it "finds the app by name" do
-        Dumbwaiter::App.find(fake_stack, "goose", fake_opsworks).id.should == "amazing"
+        Dumbwaiter::App.find(real_stack, "goose", fake_opsworks).id.should == "amazing"
       end
     end
 
     context "when the app does not exist" do
       it "blows up" do
         expect {
-          Dumbwaiter::App.find(fake_stack, "teeth", fake_opsworks)
+          Dumbwaiter::App.find(real_stack, "teeth", fake_opsworks)
         }.to raise_error(Dumbwaiter::App::NotFound)
       end
     end
@@ -72,14 +85,14 @@ describe Dumbwaiter::App do
   describe ".find" do
     context "when the app exists" do
       it "finds the app by id" do
-        Dumbwaiter::App.find_by_id(fake_stack, "amazing", fake_opsworks).name.should == "goose"
+        Dumbwaiter::App.find_by_id(real_stack, "amazing", fake_opsworks).name.should == "goose"
       end
     end
 
     context "when the app does not exist" do
       it "blows up" do
         expect {
-          Dumbwaiter::App.find_by_id(fake_stack, "teeth", fake_opsworks)
+          Dumbwaiter::App.find_by_id(real_stack, "teeth", fake_opsworks)
         }.to raise_error(Dumbwaiter::App::NotFound)
       end
     end

data/spec/lib/dumbwaiter/cli_spec.rb

@@ -1,23 +1,20 @@
 require "spec_helper"
 
 describe Dumbwaiter::Cli do
-  let(:fake_app) { double(:app, name: "reifel") }
-  let(:fake_layer) { double(:layer, shortname: "beans") }
-  let(:fake_stack) { double(:stack, name: "ducks", id: "wat", apps: [fake_app]) }
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let!(:fake_stack) { fake_opsworks.make_stack("amazing", "ducks") }
+  let!(:fake_layer) { fake_opsworks.make_layer(fake_stack, "mighty", "beans") }
+  let!(:fake_app) { fake_opsworks.make_app(fake_stack, "delightful", "reifel") }
 
   subject(:cli) { Dumbwaiter::Cli.new }
 
-  before do
-    Dumbwaiter::Stack.stub(all: [fake_stack])
-    Dumbwaiter::App.stub(all: [fake_app])
-    Dumbwaiter::Layer.stub(all: [fake_layer])
-  end
+  before { Aws::OpsWorks.stub(new: fake_opsworks) }
 
   describe "#deploy" do
     context "when the stack exists" do
       context "when the app exists" do
         it "deploys the stack with the resolved id" do
-          fake_app.should_receive(:deploy).with("corn")
+          Dumbwaiter::App.any_instance.should_receive(:deploy).with("corn")
           cli.deploy("ducks", "reifel", "corn")
         end
       end
@@ -40,7 +37,7 @@ describe Dumbwaiter::Cli do
     context "when the stack exists" do
       context "when the app exists" do
         it "deploys the stack with the resolved id" do
-          fake_app.should_receive(:rollback)
+          Dumbwaiter::App.any_instance.should_receive(:rollback)
           cli.rollback("ducks", "reifel")
         end
       end
@@ -61,40 +58,38 @@ describe Dumbwaiter::Cli do
 
   describe "#list" do
     context "when the stack exists" do
-      before { fake_stack.stub(deployments: [fake_deployment]) }
-
       context "when the deployment is a rollback" do
-        let(:fake_deployment) { double(:deployment, command_name: "rollback", to_log: "oops!") }
+        before { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "rollback") }
 
         it "lists the deployment" do
-          Kernel.should_receive(:puts).with("oops!")
+          Kernel.should_receive(:puts) { |m| m.should =~ /rollback/ }
           cli.list("ducks")
         end
       end
 
       context "when the deployment is a deploy" do
-        let(:fake_deployment) { double(:deployment, command_name: "deploy", to_log: "whee!") }
+        before { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "deploy") }
 
         it "lists the deployment" do
-          Kernel.should_receive(:puts).with("whee!")
+          Kernel.should_receive(:puts) { |m| m.should =~ /deploy/ }
           cli.list("ducks")
         end
       end
 
       context "when the deployment is a custom cookbook update" do
-        let(:fake_deployment) { double(:deployment, command_name: "update_custom_cookbooks", to_log: "whee!") }
+        before { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "update_custom_cookbooks") }
 
         it "lists the deployment" do
-          Kernel.should_receive(:puts).with("whee!")
+          Kernel.should_receive(:puts) { |m| m.should =~ /update_custom_cookbooks/ }
           cli.list("ducks")
         end
       end
 
       context "when the deployment is a recipe execution" do
-        let(:fake_deployment) { double(:deployment, command_name: "execute_recipes", to_log: "whee!") }
+        before { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "execute_recipes") }
 
         it "lists the deployment" do
-          Kernel.should_receive(:puts).with("whee!")
+          Kernel.should_receive(:puts) { |m| m.should =~ /execute_recipes/ }
           cli.list("ducks")
         end
       end
@@ -118,10 +113,8 @@ describe Dumbwaiter::Cli do
 
   describe "#layers" do
     context "when the stack exists" do
-      before { fake_stack.stub(layers: [fake_layer]) }
-
       it "lists the layers" do
-        Kernel.should_receive(:puts).with("beans")
+        Kernel.should_receive(:puts).with(fake_layer.shortname)
         cli.layers("ducks")
       end
     end
@@ -136,7 +129,7 @@ describe Dumbwaiter::Cli do
   describe "#rechef" do
     context "when the stack exists" do
       it "deploys the stack with the resolved id" do
-        fake_stack.should_receive(:rechef)
+        Dumbwaiter::Stack.any_instance.should_receive(:rechef)
         cli.rechef("ducks")
       end
     end
@@ -152,7 +145,7 @@ describe Dumbwaiter::Cli do
     context "when the stack exists" do
       context "when the layer exists" do
         it "runs the recipe on the layer" do
-          fake_layer.should_receive(:run_recipe).with("meatballs")
+          Dumbwaiter::Layer.any_instance.should_receive(:run_recipe).with("meatballs")
           cli.run_recipe("ducks", "beans", "meatballs")
         end
       end

data/spec/lib/dumbwaiter/deployment_custom_json_spec.rb

@@ -7,14 +7,14 @@ describe Dumbwaiter::DeploymentCustomJson do
     let(:custom_json) { {} }
 
     its(:app_name) { should be_nil }
-    its(:git_ref) { should == "HEAD" }
+    its(:revision) { should be_nil }
   end
 
   context "when the custom json contains a revision" do
     let(:custom_json) { {deploy: {"reifel" => {scm: {revision: "corn"}}}} }
 
     its(:app_name) { should == "reifel" }
-    its(:git_ref) { should == "corn" }
+    its(:revision) { should == "corn" }
   end
 
   describe ".create" do
@@ -28,6 +28,6 @@ describe Dumbwaiter::DeploymentCustomJson do
     subject(:json) { Dumbwaiter::DeploymentCustomJson.from_json(json_string) }
 
     its(:app_name) { should == "toes" }
-    its(:git_ref) { should == "jam" }
+    its(:revision) { should == "jam" }
   end
 end

data/spec/lib/dumbwaiter/deployment_spec.rb

@@ -1,67 +1,58 @@
 require "spec_helper"
 
 describe Dumbwaiter::Deployment do
-  let(:fake_command) { double(:command, name: "deplode") }
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let(:fake_stack) { fake_opsworks.make_stack("pancakes") }
+  let(:fake_app) { fake_opsworks.make_app(fake_stack, "yo") }
+  let!(:fake_user_profile) { fake_opsworks.make_user_profile("ie", "goose") }
   let(:custom_json) { JSON.dump(deploy: {"hockey" => {scm: {revision: "eh-buddy"}}}) }
-  let(:fake_deployment) do
-    double(:deployment,
-      created_at: "last Tuesday",
-      command: fake_command,
-      status: "badical",
-      custom_json: custom_json,
-      iam_user_arn: "ie",
-      comment: "i love sports"
-    )
-  end
-  let(:fake_deployments) { double(:deployments, deployments: [fake_deployment]) }
-  let(:fake_user_profile) { double(:user_profile, name: "goose") }
-  let(:fake_user_profiles) { double(:user_profiles, user_profiles: [fake_user_profile]) }
-  let(:fake_opsworks) { double(:opsworks, describe_deployments: fake_deployments, describe_user_profiles: fake_user_profiles) }
+  let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "deploy", "badical", custom_json, DateTime.parse("last Tuesday").to_s, "ie", "i love sports") }
+  let(:real_stack) { Dumbwaiter::Stack.new(fake_stack, fake_opsworks) }
 
-  subject(:deployment) { Dumbwaiter::Deployment.new(fake_deployment, fake_opsworks) }
+  subject(:deployment) { Dumbwaiter::Deployment.new(real_stack, fake_deployment, fake_opsworks) }
 
-  its(:opsworks_deployment) { should == fake_deployment }
   its(:created_at) { should == DateTime.parse("last Tuesday") }
-  its(:command_name) { should == "deplode" }
+  its(:command_name) { should == "deploy" }
   its(:status) { should == "badical" }
   its(:comment) { should == "i love sports" }
-  its(:git_ref) { should == "eh-buddy" }
-  its(:to_log) { should == "#{DateTime.parse("last Tuesday")} - goose - deplode - badical - eh-buddy" }
+  its(:revision) { should == "eh-buddy" }
   its(:user_name) { should == "goose" }
 
+  context "when the command name is deploy" do
+    its(:to_log) { should == "#{DateTime.parse("last Tuesday")} - goose - deploy - badical - eh-buddy" }
+  end
+
+  context "when the command name is not deploy" do
+    let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "floss", "badical", custom_json, DateTime.parse("last Tuesday").to_s, "ie", "i love sports") }
+
+    its(:to_log) { should == "#{DateTime.parse("last Tuesday")} - goose - floss - badical" }
+  end
+
   context "when the iam user arn is nil" do
-    let(:fake_deployment) do
-      double(:deployment,
-        created_at: "last Tuesday",
-        command: fake_command,
-        status: "badical",
-        custom_json: custom_json,
-        iam_user_arn: nil
-      )
-    end
+    let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "deploy", "badical", custom_json, DateTime.parse("last Tuesday").to_s, nil, "i love sports") }
 
-    its(:user_name) { should == "?" }
+    its(:user_name) { should == "OpsWorks" }
+  end
+
+  context "when the iam user arn does not exist" do
+    let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "deploy", "badical", custom_json, DateTime.parse("last Tuesday").to_s, "wait which user is this", "i love sports") }
+
+    before { fake_opsworks.clear }
+
+    its(:user_name) { should == "OpsWorks" }
   end
 
   context "when custom_json is nil" do
-    let(:fake_deployment) do
-      double(:deployment,
-        created_at: "yo",
-        command: fake_command,
-        status: "badical",
-        custom_json: nil
-      )
-    end
+    let(:real_app) { Dumbwaiter::App.new(real_stack, fake_app, fake_opsworks) }
+    let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app, "jello", "deploy", "badical", nil, DateTime.parse("last Tuesday").to_s, "ie", "i love sports") }
 
-    its(:git_ref) { should == "HEAD" }
+    its(:revision) { should == "#{real_app.revision}@{#{DateTime.parse("last Tuesday")}}" }
   end
 
   describe ".all" do
-    let(:fake_stack) { double(:stack, id: "pancakes") }
-
     it "fetches all the deployments" do
-      fake_opsworks.should_receive(:describe_deployments).with(stack_id: "pancakes")
-      Dumbwaiter::Deployment.all(fake_stack, fake_opsworks).should have(1).app
+      fake_opsworks.should_receive(:describe_deployments).with(stack_id: "pancakes").and_call_original
+      Dumbwaiter::Deployment.all(real_stack, fake_opsworks).should have(1).deployment
     end
   end
 end

data/spec/lib/dumbwaiter/instance_spec.rb

@@ -1,22 +1,21 @@
 require "spec_helper"
 
 describe Dumbwaiter::Instance do
-  let(:fake_stack) { double(:stack, id: "pancakes") }
-  let(:fake_layer) { double(:layer, id: "pinto", stack: fake_stack) }
-
-  let(:fake_instance) { double(:instance, instance_id: "dragons") }
-  let(:fake_instances) { double(:instances, instances: [fake_instance]) }
-  let(:fake_opsworks) { double(:opsworks, describe_instances: fake_instances) }
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let(:fake_stack) { fake_opsworks.make_stack }
+  let(:fake_layer) { fake_opsworks.make_layer(fake_stack) }
+  let!(:fake_instance) { fake_opsworks.make_instance(fake_stack, fake_layer) }
 
   subject(:instance) { Dumbwaiter::Instance.new(fake_layer, fake_instance, fake_opsworks) }
 
-  its(:opsworks_instance) { should == fake_instance }
-  its(:id) { should == "dragons" }
+  its(:id) { should == fake_instance.instance_id }
 
   describe ".all" do
+    let(:real_layer) { Dumbwaiter::Layer.new(fake_stack, fake_layer, fake_opsworks) }
+
     it "fetches all the instances" do
-      fake_opsworks.should_receive(:describe_instances).with(layer_id: "pinto")
-      Dumbwaiter::Instance.all(fake_layer, fake_opsworks).should have(1).instance
+      fake_opsworks.should_receive(:describe_instances).with(layer_id: fake_layer.layer_id).and_call_original
+      Dumbwaiter::Instance.all(real_layer, fake_opsworks).should have(1).instance
     end
   end
 end

data/spec/lib/dumbwaiter/layer_spec.rb

@@ -1,43 +1,41 @@
 require "spec_helper"
 
 describe Dumbwaiter::Layer do
-  let(:fake_stack) { double(:stack, id: "pancakes") }
-  let(:fake_layer) { double(:layer, shortname: "meaty", layer_id: "pinto") }
-  let(:fake_layers) { double(:layers, layers: [fake_layer]) }
-  let(:fake_instance) { double(:instance, id: "dragons") }
-  let(:fake_instances) { double(:instances, instances: [fake_instance]) }
-  let(:fake_opsworks) { double(:opsworks, describe_layers: fake_layers, describe_instances: fake_instances) }
-
-  before do
-    Dumbwaiter::Instance.stub(all: [fake_instance])
-  end
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let(:fake_stack) { fake_opsworks.make_stack("pancakes") }
+  let(:fake_layer) { fake_opsworks.make_layer(fake_stack, "pinto", "meaty") }
+  let!(:fake_instance) { fake_opsworks.make_instance(fake_layer, fake_stack, "dragons") }
+
+  let(:real_stack) { Dumbwaiter::Stack.new(fake_stack, fake_opsworks) }
 
-  subject(:layer) { Dumbwaiter::Layer.new(fake_stack, fake_layer, fake_opsworks) }
+  subject(:layer) { Dumbwaiter::Layer.new(real_stack, fake_layer, fake_opsworks) }
 
   its(:opsworks_layer) { should == fake_layer }
   its(:id) { should == "pinto" }
   its(:shortname) { should == "meaty" }
 
-  its(:instances) { should == [fake_instance] }
+  it { should have(1).instances }
 
   describe ".all" do
+    let(:real_stack) { Dumbwaiter::Stack.new(fake_stack, fake_opsworks) }
+
     it "fetches all the deployments" do
-      fake_opsworks.should_receive(:describe_layers).with(stack_id: "pancakes")
-      Dumbwaiter::Layer.all(fake_stack, fake_opsworks).should have(1).layer
+      fake_opsworks.should_receive(:describe_layers).with(stack_id: "pancakes").and_call_original
+      Dumbwaiter::Layer.all(real_stack, fake_opsworks).should have(1).layer
     end
   end
 
   describe ".find" do
     context "when the layer exists" do
       it "finds the layer by name" do
-        Dumbwaiter::Layer.find(fake_stack, "meaty", fake_opsworks).shortname.should == "meaty"
+        Dumbwaiter::Layer.find(real_stack, "meaty", fake_opsworks).shortname.should == "meaty"
       end
     end
 
     context "when the layer does not exist" do
       it "blows up" do
         expect {
-          Dumbwaiter::Layer.find(fake_stack, "brick", fake_opsworks)
+          Dumbwaiter::Layer.find(real_stack, "brick", fake_opsworks)
         }.to raise_error(Dumbwaiter::Layer::NotFound)
       end
     end

data/spec/lib/dumbwaiter/stack_spec.rb

@@ -1,30 +1,22 @@
 require "spec_helper"
 
 describe Dumbwaiter::Stack do
-  let(:fake_stack) { double(:stack, name: "ducks", stack_id: "cool", attributes: {"Color" => "hot pink"}) }
-  let(:fake_stacks) { double(:stacks, stacks: [fake_stack]) }
-  let(:fake_opsworks) { double(:opsworks, describe_stacks: fake_stacks) }
-  let(:fake_app) { double(:app) }
-  let(:fake_deployment) { double(:deployment) }
-  let(:fake_layer) { double(:layer) }
+  let(:fake_opsworks) { Dumbwaiter::Mock.new }
+  let!(:fake_stack) { fake_opsworks.make_stack("cool", "ducks", "hot pink") }
+  let!(:fake_app) { fake_opsworks.make_app(fake_stack) }
+  let!(:fake_deployment) { fake_opsworks.make_deployment(fake_stack, fake_app) }
+  let!(:fake_layer) { fake_opsworks.make_layer(fake_stack) }
 
   subject(:stack) { Dumbwaiter::Stack.new(fake_stack, fake_opsworks) }
 
-  before do
-    Dumbwaiter::App.stub(all: [fake_app])
-    Dumbwaiter::Deployment.stub(all: [fake_deployment])
-    Dumbwaiter::Layer.stub(all: [fake_layer])
-  end
+  it { should have(1).apps }
+  it { should have(1).deployments }
+  it { should have(1).layers }
 
-  its(:opsworks_stack) { should == fake_stack }
   its(:id) { should == "cool" }
   its(:name) { should == "ducks" }
   its(:color) { should == "hot pink" }
 
-  its(:apps) { should == [fake_app] }
-  its(:deployments) { should == [fake_deployment] }
-  its(:layers) { should == [fake_layer] }
-
   describe ".all" do
     it "fetches all the stacks" do
       Dumbwaiter::Stack.all(fake_opsworks).should have(1).stack

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "dumbwaiter"
+require "dumbwaiter/mock"
 
 Aws.config = {access_key_id: "tacos", secret_access_key: "secret chocolate"}
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dumbwaiter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Doc Ritezel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-21 00:00:00.000000000 Z
+date: 2013-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core
@@ -94,6 +94,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Hoist your code up to Opsworks
 email:
 - doc@ministryofvelocity.com
@@ -120,6 +134,7 @@ files:
 - lib/dumbwaiter/deployment_custom_json.rb
 - lib/dumbwaiter/instance.rb
 - lib/dumbwaiter/layer.rb
+- lib/dumbwaiter/mock.rb
 - lib/dumbwaiter/stack.rb
 - lib/dumbwaiter/user_profile.rb
 - lib/dumbwaiter/version.rb