engineyard 1.4.29 → 1.7.0.pre2

data/lib/engineyard/model/log.rb

@@ -1,9 +0,0 @@
-module EY
-  module Model
-    class Log < ApiStruct.new(:id, :role, :main, :custom)
-      def instance_name
-        "#{role} #{id}"
-      end
-    end
-  end
-end

data/lib/engineyard/model/user.rb

@@ -1,6 +0,0 @@
-module EY
-  module Model
-    class User < ApiStruct.new(:id, :name, :email)
-    end
-  end
-end

data/lib/engineyard/resolver.rb

@@ -1,134 +0,0 @@
-module EY
-  class Resolver
-    attr_reader :api
-
-    def initialize(api)
-      @api = api
-    end
-
-    def environment(options)
-      raise ArgumentError if options[:app_name]
-      candidates, account_candidates, app_candidates, environment_candidates = filter_candidates(options)
-
-      environments = candidates.map{ |c| [c[:account_name], c[:environment_name]] }.uniq.map do |account_name, environment_name|
-        api.environments.named(environment_name, account_name)
-      end
-
-      if environments.empty?
-        if options[:environment_name]
-          raise EY::NoEnvironmentError.new(options[:environment_name])
-        else
-          raise EY::NoAppError.new(options[:repo])
-        end
-      elsif environments.size > 1
-        if options[:environment_name]
-          message = "Multiple environments possible, please be more specific:\n\n"
-          candidates.map{|e| [e[:account_name], e[:environment_name]]}.uniq.each do |account_name, environment_name|
-            message << "\t#{environment_name.ljust(25)} # ey <command> --environment='#{environment_name}' --account='#{account_name}'\n"
-          end
-          raise MultipleMatchesError.new(message)
-        else
-          raise EY::AmbiguousEnvironmentGitUriError.new(environments)
-        end
-      end
-      environments.first
-    end
-
-    def app_and_environment(options)
-      candidates, account_candidates, app_candidates, environment_candidates = filter_candidates(options)
-
-      if candidates.empty?
-        if account_candidates.empty? && options[:account_name]
-          raise NoMatchesError.new("There were no accounts that matched #{options[:account_name]}")
-        elsif app_candidates.empty?
-          if options[:app_name]
-            raise InvalidAppError.new(options[:app_name])
-          else
-            raise NoAppError.new(options[:repo])
-          end
-        elsif environment_candidates.empty?
-          raise NoEnvironmentError.new(options[:environment_name])
-        else
-          message = "The matched apps & environments do not correspond with each other.\n"
-          message << "Applications:\n"
-          app_candidates.map{|ad| [ad[:account_name], ad[:app_name]]}.uniq.each do |account_name, app_name|
-            app = api.apps.named(app_name, account_name)
-            message << "\t#{app.name}\n"
-            app.environments.each do |env|
-              message << "\t\t#{env.name} # ey <command> -e #{env.name} -a #{app.name}\n"
-            end
-          end
-        end
-        raise NoMatchesError.new(message)
-      elsif candidates.size > 1
-        message = "Multiple app deployments possible, please be more specific:\n\n"
-        candidates.map{|c| [c[:account_name], c[:app_name]]}.uniq.each do |account_name, app_name|
-          message << "#{app_name}\n"
-          candidates.select {|c| c[:app_name] == app_name && c[:account_name] == account_name}.map{|c| c[:environment_name]}.uniq.each do |env_name|
-            message << "\t#{env_name.ljust(25)} # ey <command> --environment='#{env_name}' --app='#{app_name}' --account='#{account_name}'\n"
-          end
-        end
-        raise MultipleMatchesError.new(message)
-      end
-      result = candidates.first
-      [api.apps.named(result[:app_name], result[:account_name]), api.environments.named(result[:environment_name], result[:account_name])]
-    end
-
-    private
-
-    def app_deployments
-      @app_deployments ||= api.apps.map do |app|
-        app.environments.map do |environment|
-          {
-            :app_name => app.name.downcase,
-            :repository_uri => app.repository_uri,
-            :environment_name => environment.name.downcase,
-            :account_name => app.account.name.downcase,
-          }
-        end
-      end.flatten
-    end
-
-    def filter_candidates(options)
-      raise ArgumentError if options.empty?
-
-      candidates = app_deployments
-
-      account_candidates = filter_candidates_by(:account_name, options, candidates)
-
-      app_candidates = if options[:app_name]
-                         filter_candidates_by(:app_name, options, candidates)
-                       elsif options[:repo]
-                         filter_by_repo(candidates, options[:repo])
-                       else
-                         candidates
-                       end
-
-      environment_candidates = filter_candidates_by(:environment_name, options, candidates)
-      candidates = app_candidates & environment_candidates & account_candidates
-      [candidates, account_candidates, app_candidates, environment_candidates]
-    end
-
-    def filter_by_repo(candidates, repo)
-      results = candidates.select do |candidate|
-        repo.has_remote?(candidate[:repository_uri])
-      end
-
-      if results.empty?
-        candidates
-      else
-        results
-      end
-    end
-
-    def filter_candidates_by(type, options, candidates)
-      if options[type] && candidates.any?{|c| c[type] == options[type].downcase }
-        candidates.select {|c| c[type] == options[type].downcase }
-      elsif options[type]
-        candidates.select {|c| c[type][options[type].downcase] }
-      else
-        candidates
-      end
-    end
-  end
-end

data/lib/engineyard/rest_client_ext.rb

@@ -1,9 +0,0 @@
-module RestClient
-  module AbstractResponse
-    private
-
-    def parse_cookie cookie_content
-      {}
-    end
-  end
-end

data/lib/engineyard/ruby_ext.rb

@@ -1,9 +0,0 @@
-class Object
-  unless respond_to?(:tap)
-    # Ruby 1.9 has it, 1.8 doesn't
-    def tap
-      yield self
-      self
-    end
-  end
-end

data/spec/engineyard/api_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe EY::API do
-  it "gets the api token from ~/.eyrc if possible" do
-    write_eyrc({"api_token" => "asdf"})
-    EY::API.new.should == EY::API.new("asdf")
-  end
-
-  context "fetching the token from EY cloud" do
-    before(:each) do
-      FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :body => %|{"api_token": "asdf"}|, :content_type => 'application/json')
-      @token = EY::API.fetch_token("a@b.com", "foo")
-    end
-
-    it "returns an EY::API" do
-      @token.should == "asdf"
-    end
-
-    it "puts the api token into .eyrc" do
-      read_eyrc["api_token"].should == "asdf"
-    end
-  end
-
-  it "raises InvalidCredentials when the credentials are invalid" do
-    FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :status => 401, :content_type => 'application/json')
-
-    lambda {
-      EY::API.fetch_token("a@b.com", "foo")
-    }.should raise_error(EY::Error)
-  end
-
-  it "raises RequestFailed with a friendly error when cloud is under maintenance" do
-    FakeWeb.register_uri(:post, "https://cloud.engineyard.com/api/v2/authenticate", :status => 502, :content_type => 'text/html')
-
-    lambda {
-      EY::API.fetch_token("a@b.com", "foo")
-    }.should raise_error(EY::API::RequestFailed, /API is temporarily unavailable/)
-  end
-end

data/spec/engineyard/collection/apps_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe EY::Collection::Apps do
-  before do
-    @collection_class = EY::Collection::Apps
-    @collection = @collection_class.new([
-      EY::Model::App.from_hash("id" => 1234, "name" => "app_production"),
-      EY::Model::App.from_hash("id" => 4321, "name" => "app_staging"),
-      EY::Model::App.from_hash("id" => 8765, "name" => "bigapp_staging"),
-      EY::Model::App.from_hash("id" => 4532, "name" => "app_duplicate"),
-      EY::Model::App.from_hash("id" => 4533, "name" => "app_duplicate"),
-    ])
-  end
-
-    include_examples "model collections"
-end

data/spec/engineyard/collection/environments_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe EY::Collection::Environments do
-  before do
-    @collection_class = EY::Collection::Environments
-    @collection = @collection_class.new([
-      EY::Model::Environment.from_hash("id" => 1234, "name" => "app_production"),
-      EY::Model::Environment.from_hash("id" => 4321, "name" => "app_staging"),
-      EY::Model::Environment.from_hash("id" => 8765, "name" => "bigapp_staging"),
-      EY::Model::Environment.from_hash("id" => 4532, "name" => "app_duplicate"),
-      EY::Model::Environment.from_hash("id" => 4533, "name" => "app_duplicate"),
-    ])
-  end
-
-  include_examples "model collections"
-end

data/spec/engineyard/model/api_struct_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe EY::Model::ApiStruct do
-  class Foo < EY::Model::ApiStruct.new(:fruit, :veggie); end
-
-  it "acts like a normal struct" do
-    f = Foo.new("banana")
-
-    f.fruit.should == "banana"
-  end
-
-  describe "from_hash initializer" do
-    it "assigns values from string keys" do
-      f = Foo.from_hash("fruit" => "banana")
-      f.should == Foo.new("banana")
-    end
-
-    it "assigns values from symbol keys" do
-      f = Foo.from_hash(:fruit => "banana")
-      f.should == Foo.new("banana")
-    end
-  end
-
-  describe "from_array initializer" do
-    it "provides a from_array initializer" do
-      f = Foo.from_array([:fruit => "banana"])
-      f.should == [Foo.new("banana")]
-    end
-
-    it "handles a common-arguments hash as the second argument" do
-      foos = Foo.from_array(
-        [{:fruit => "banana"}, {:fruit => 'apple'}],
-        :veggie => 'kale')
-      foos.should == [
-        Foo.new("banana", "kale"),
-        Foo.new("apple", "kale"),
-      ]
-    end
-  end
-
-end

data/spec/engineyard/model/environment_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-describe "EY::Model::Environment#rebuild" do
-  it "hits the rebuild action in the API" do
-    env = EY::Model::Environment.from_hash({
-        "id" => 46534,
-        "api" => ey_api,
-      })
-
-    FakeWeb.register_uri(
-      :put,
-      "https://cloud.engineyard.com/api/v2/environments/#{env.id}/update_instances",
-      :body => ''
-    )
-
-    env.rebuild
-
-    FakeWeb.should have_requested(:put, "https://cloud.engineyard.com/api/v2/environments/#{env.id}/update_instances")
-  end
-end
-
-describe "EY::Model::Environment#run_custom_recipes" do
-  it "hits the rebuild action in the API" do
-    env = EY::Model::Environment.from_hash({
-        "id" => 46534,
-        "api" => ey_api,
-      })
-
-    FakeWeb.register_uri(
-      :put,
-      "https://cloud.engineyard.com/api/v2/environments/#{env.id}/run_custom_recipes",
-      :body => '',
-      :content_type => 'application/json'
-    )
-
-    env.run_custom_recipes
-
-    FakeWeb.should have_requested(:put, "https://cloud.engineyard.com/api/v2/environments/#{env.id}/run_custom_recipes")
-  end
-end
-
-describe "EY::Model::Environment.from_array" do
-  it "returns a smart collection, not just a dumb array" do
-    api_data = [
-      {"id" => 32340, "name" => 'iceberg'},
-      {"id" => 9433, "name" => 'zoidberg'},
-    ]
-
-    collection = EY::Model::Environment.from_array(api_data)
-    collection.should respond_to(:each)
-    collection.should respond_to(:match_one)
-  end
-end
-
-describe "EY::Model::Environment#instances" do
-  it "returns instances" do
-    instance_data = {
-      "id" => "1",
-      "role" => "app_master",
-      "amazon_id" => "i-likebeer",
-      "public_hostname" => "banana_master"
-    }
-
-    env = EY::Model::Environment.from_hash({
-        "id" => 10291,
-        "api" => ey_api,
-        "instances" => [instance_data],
-      })
-
-    FakeWeb.register_uri(:get,
-      "https://cloud.engineyard.com/api/v2/environments/#{env.id}/instances",
-      :body => {"instances" => [instance_data]}.to_json,
-      :content_type => 'application/json'
-    )
-
-    env.should have(1).instances
-    env.instances.first.should == EY::Model::Instance.from_hash(instance_data.merge(:environment => env))
-  end
-end
-
-describe "EY::Model::Environment#app_master!" do
-  def make_env_with_master(app_master)
-    if app_master
-      app_master = {
-        "id" => 44206,
-        "role" => "solo",
-      }.merge(app_master)
-    end
-
-    EY::Model::Environment.from_hash({
-        "id" => 11830,
-        "name" => "guinea-pigs-are-delicious",
-        "app_master" => app_master,
-        "instances" => [app_master].compact,
-      })
-  end
-
-
-  it "returns the app master if it's present and running" do
-    env = make_env_with_master("status" => "running")
-    env.app_master!.should_not be_nil
-    env.app_master!.id.should == 44206
-  end
-
-  it "raises an error if the app master is in a non-running state" do
-    env = make_env_with_master("status" => "error")
-    lambda {
-      env.app_master!
-    }.should raise_error(EY::BadAppMasterStatusError)
-  end
-
-  it "returns the app master if told to ignore the app master being in a non-running state" do
-    env = make_env_with_master("status" => "error")
-    env.ignore_bad_master = true
-    env.app_master!.should_not be_nil
-    env.app_master!.id.should == 44206
-  end
-
-  it "raises an error if the app master is absent" do
-    env = make_env_with_master(nil)
-    lambda {
-      env.app_master!
-    }.should raise_error(EY::NoAppMasterError)
-  end
-end
-
-describe "EY::Model::Environment#shorten_name_for(app)" do
-  def short(environment_name, app_name)
-    env = EY::Model::Environment.from_hash({:name => environment_name})
-    app = EY::Model::App.from_hash({:name => app_name})
-    env.shorten_name_for(app)
-  end
-
-  it "turns myapp+myapp_production to production" do
-    short('myapp_production', 'myapp').should == 'production'
-  end
-
-  it "turns product+production to product (leaves it alone)" do
-    short('production', 'product').should == 'production'
-  end
-
-  it "leaves the environment name alone when the app name appears in the middle" do
-    short('hattery', 'ate').should == 'hattery'
-  end
-
-  it "does not produce an empty string when the names are the same" do
-    short('dev', 'dev').should == 'dev'
-  end
-end
-
-describe "EY::Model::Environment#migration_command" do
-  before do
-    @app = EY::Model::App.from_hash({:name => 'fake'})
-    @migrate = EY::Model::Environment.from_hash({
-        "id" => 10291,
-        "api" => ey_api,
-        'name' => 'migrate',
-        'deployment_configurations' => {'fake' => {'migrate' => {'command' => 'fake db:migrate', 'perform' => true}}}
-    })
-
-    @no_migrate = EY::Model::Environment.from_hash({
-        "id" => 10291,
-        "api" => ey_api,
-        'name' => 'no_migrate',
-        'deployment_configurations' => {'fake' => {'migrate' => {'command' => 'fake db:migrate', 'perform' => false}}}
-    })
-  end
-
-  it "returns the migration command for the environment when the perform flag is true" do
-    @migrate.migration_command(@app, {}).should == 'fake db:migrate'
-  end
-
-  it "returns nil when the perform flag in the environment is false" do
-    @no_migrate.migration_command(@app, {}).should == nil
-  end
-
-  context "with the migrate deploy option" do
-    it "returns the default migration command when is true" do
-      @migrate.migration_command(@app, {'migrate' => true}).should == 'rake db:migrate'
-    end
-
-    it "return the custom migration command when is a string" do
-      @migrate.migration_command(@app, {'migrate' => 'foo migrate'}).should == 'foo migrate'
-    end
-  end
-
-  context "with the migrate option in the global configuration" do
-    it "return the default migration command when the option is true" do
-      EY.config.environments['migrate'] = {'migrate' => true, 'migration_command' => 'bar migrate'}
-      @migrate.migration_command(@app, {}).should == 'bar migrate'
-    end
-
-    it "return the custom migration command when the option is a string" do
-      EY.config.environments['migrate'] = {'migration_command' => 'bar migrate'}
-      @migrate.migration_command(@app, {}).should == 'bar migrate'
-    end
-  end
-end