ey-core 3.4.4 → 3.4.5

data/lib/ey-core/requests/upload_recipes_for_environment.rb

@@ -1,28 +1,28 @@
-class Ey::Core::Client
-  class Real
-    def upload_recipes_for_environment(params={})
-      file = params.delete("file")
-      id   = params.delete("id")
-      url  = params.delete("url")
-
-
-      request(
-        :body    => {"file" => Faraday::UploadIO.new(file, "application/x-gzip")},
-        :headers => {"Content-Type" => "multipart/form-data" },
-        :method  => :post,
-        :path    => "environments/#{id}/recipes",
-        :url     => url,
-      )
-    end
-  end
-
-  class Mock
-    def upload_recipes_for_environment(params={})
-      environment = find(:environments, resource_identity(params))
-      environment["custom_recipes"] = "https://#{self.uuid}.s3.amazonaws.com/#{self.uuid}?X-Amz-Expires=1800"
-      self.data[:environments][environment["id"]] = environment
-
-      response(status: 204)
-    end
-  end
-end
+class Ey::Core::Client
+  class Real
+    def upload_recipes_for_environment(params={})
+      file = params.delete("file")
+      id   = params.delete("id")
+      url  = params.delete("url")
+
+
+      request(
+        :body    => {"file" => Faraday::UploadIO.new(file, "application/x-gzip")},
+        :headers => {"Content-Type" => "multipart/form-data" },
+        :method  => :post,
+        :path    => "environments/#{id}/recipes",
+        :url     => url,
+      )
+    end
+  end
+
+  class Mock
+    def upload_recipes_for_environment(params={})
+      environment = find(:environments, resource_identity(params))
+      environment["custom_recipes"] = "https://#{self.uuid}.s3.amazonaws.com/#{self.uuid}?X-Amz-Expires=1800"
+      self.data[:environments][environment["id"]] = environment
+
+      response(status: 204)
+    end
+  end
+end

data/lib/ey-core/response.rb

@@ -1,59 +1,59 @@
-class Ey::Core::Response
-  class Error < StandardError
-    attr_reader :response
-
-    def initialize(response)
-      @response = response
-      super(
-        {
-          :status  => response.status,
-          :headers => response.headers,
-          :body    => response.body,
-          :request => response.request
-        }.inspect
-      )
-    end
-
-    def error_type
-      self.class.name.split(":").last
-    end
-  end
-
-  BadRequest        = Class.new(Error)
-  Conflict          = Class.new(Error)
-  NotFound          = Class.new(Error)
-  RateLimitExceeded = Class.new(Error)
-  Unauthorized      = Class.new(Error)
-  Unexpected        = Class.new(Error)
-  Unprocessable     = Class.new(Error)
-
-  EXCEPTION_MAPPING = {
-    400 => BadRequest,
-    401 => Unauthorized,
-    404 => NotFound,
-    409 => Conflict,
-    422 => Unprocessable,
-    429 => RateLimitExceeded,
-    500 => Unexpected,
-  }
-
-  attr_reader :headers, :status, :body, :request
-
-  def initialize(opts = {})
-    @status  = opts[:status]
-    @headers = opts[:headers]
-    @body    = opts[:body]
-    @request = opts[:request]
-  end
-
-  def successful?
-    self.status >= 200 && self.status <= 299 || self.status == 304
-  end
-
-  def raise!
-    if !successful?
-      raise (EXCEPTION_MAPPING[self.status] || Error).new(self)
-    else self
-    end
-  end
-end
+class Ey::Core::Response
+  class Error < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(
+        {
+          :status  => response.status,
+          :headers => response.headers,
+          :body    => response.body,
+          :request => response.request
+        }.inspect
+      )
+    end
+
+    def error_type
+      self.class.name.split(":").last
+    end
+  end
+
+  BadRequest        = Class.new(Error)
+  Conflict          = Class.new(Error)
+  NotFound          = Class.new(Error)
+  RateLimitExceeded = Class.new(Error)
+  Unauthorized      = Class.new(Error)
+  Unexpected        = Class.new(Error)
+  Unprocessable     = Class.new(Error)
+
+  EXCEPTION_MAPPING = {
+    400 => BadRequest,
+    401 => Unauthorized,
+    404 => NotFound,
+    409 => Conflict,
+    422 => Unprocessable,
+    429 => RateLimitExceeded,
+    500 => Unexpected,
+  }
+
+  attr_reader :headers, :status, :body, :request
+
+  def initialize(opts = {})
+    @status  = opts[:status]
+    @headers = opts[:headers]
+    @body    = opts[:body]
+    @request = opts[:request]
+  end
+
+  def successful?
+    self.status >= 200 && self.status <= 299 || self.status == 304
+  end
+
+  def raise!
+    if !successful?
+      raise (EXCEPTION_MAPPING[self.status] || Error).new(self)
+    else self
+    end
+  end
+end

data/lib/ey-core/response_cache.rb

@@ -1,29 +1,29 @@
-class Ey::Core::ResponseCache
-  def initialize(app, options = {}, &block)
-    @app = app
-    @cache = options.fetch(:cache, &block)
-    @cache_key_prefix = options.fetch(:cache_key_prefix, :ey_core)
-  end
-
-  def call(env)
-    # Only cache "safe" requests
-    return @app.call(env) unless [:get, :head].include?(env[:method])
-
-    cache_key = [ @cache_key_prefix, env[:url].to_s ]
-    cached = @cache.read(cache_key)
-
-    if cached
-      env[:request_headers]["If-None-Match"] ||= cached[:response_headers]["Etag"]
-    end
-
-    @app.call(env).on_complete do
-      if cached && env[:status] == 304
-        env[:body] = cached[:body]
-      end
-
-      if !cached && env[:response_headers]["Etag"]
-        @cache.write(cache_key, env)
-      end
-    end
-  end
-end
+class Ey::Core::ResponseCache
+  def initialize(app, options = {}, &block)
+    @app = app
+    @cache = options.fetch(:cache, &block)
+    @cache_key_prefix = options.fetch(:cache_key_prefix, :ey_core)
+  end
+
+  def call(env)
+    # Only cache "safe" requests
+    return @app.call(env) unless [:get, :head].include?(env[:method])
+
+    cache_key = [ @cache_key_prefix, env[:url].to_s ]
+    cached = @cache.read(cache_key)
+
+    if cached
+      env[:request_headers]["If-None-Match"] ||= cached[:response_headers]["Etag"]
+    end
+
+    @app.call(env).on_complete do
+      if cached && env[:status] == 304
+        env[:body] = cached[:body]
+      end
+
+      if !cached && env[:response_headers]["Etag"]
+        @cache.write(cache_key, env)
+      end
+    end
+  end
+end

data/lib/ey-core/subscribable.rb

@@ -1,60 +1,60 @@
-module Ey::Core::Subscribable
-  def self.included(klass)
-    klass.send(:attribute, :read_channel)
-  end
-
-  def read_channel_uri
-    self.read_channel && Addressable::URI.parse(self.read_channel)
-  end
-
-  def subscribe(&block)
-    return false unless read_channel_uri
-
-    gem 'faye', '~> 1.1'
-    require 'faye' # soft dependency
-
-    # Use the same env variable as faraday to activate debug output
-    Faye.logger = Logger.new(STDOUT, level: "DEBUG") if ENV["DEBUG"]
-
-    uri = read_channel_uri
-
-    resource = self
-
-    url          = uri.omit(:query).to_s
-    token        = uri.query_values["token"]
-    subscription = uri.query_values["subscription"]
-
-    EM.run do
-      client = Faye::Client.new(url)
-      client.set_header("Authorization", "Token #{token}")
-      next_ready_check = Time.now + 5
-      handle_output = Proc.new do |m|
-        next_ready_check = Time.now + 1
-        block.call(m)
-      end
-
-      deferred = client.subscribe(subscription) do |message|
-        handle_output.call(JSON.load(message))
-      end
-
-      deferred.callback do
-        handle_output.call({"meta" => true, "created_at" => Time.now,"message" => "log output stream connection established, waiting...\n"})
-      end
-
-      deferred.errback do |error|
-        handle_output.call({"meta" => true, "created_at" => Time.now, "message" => "failed to stream output: #{error.inspect}\n"})
-        EM.stop_event_loop
-      end
-
-      EventMachine::PeriodicTimer.new(1) do
-        if Time.now > next_ready_check
-          if resource.reload.ready?
-            handle_output.call({"meta" => true, "created_at" => Time.now, "message" => "#{resource} finished"})
-            EM.stop_event_loop
-          end
-          next_ready_check = Time.now + 5
-        end
-      end
-    end
-  end
-end
+module Ey::Core::Subscribable
+  def self.included(klass)
+    klass.send(:attribute, :read_channel)
+  end
+
+  def read_channel_uri
+    self.read_channel && Addressable::URI.parse(self.read_channel)
+  end
+
+  def subscribe(&block)
+    return false unless read_channel_uri
+
+    gem 'faye', '~> 1.1'
+    require 'faye' # soft dependency
+
+    # Use the same env variable as faraday to activate debug output
+    Faye.logger = Logger.new(STDOUT, level: "DEBUG") if ENV["DEBUG"]
+
+    uri = read_channel_uri
+
+    resource = self
+
+    url          = uri.omit(:query).to_s
+    token        = uri.query_values["token"]
+    subscription = uri.query_values["subscription"]
+
+    EM.run do
+      client = Faye::Client.new(url)
+      client.set_header("Authorization", "Token #{token}")
+      next_ready_check = Time.now + 5
+      handle_output = Proc.new do |m|
+        next_ready_check = Time.now + 1
+        block.call(m)
+      end
+
+      deferred = client.subscribe(subscription) do |message|
+        handle_output.call(JSON.load(message))
+      end
+
+      deferred.callback do
+        handle_output.call({"meta" => true, "created_at" => Time.now,"message" => "log output stream connection established, waiting...\n"})
+      end
+
+      deferred.errback do |error|
+        handle_output.call({"meta" => true, "created_at" => Time.now, "message" => "failed to stream output: #{error.inspect}\n"})
+        EM.stop_event_loop
+      end
+
+      EventMachine::PeriodicTimer.new(1) do
+        if Time.now > next_ready_check
+          if resource.reload.ready?
+            handle_output.call({"meta" => true, "created_at" => Time.now, "message" => "#{resource} finished"})
+            EM.stop_event_loop
+          end
+          next_ready_check = Time.now + 5
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/test_helpers/account_helpers.rb

@@ -1,73 +1,73 @@
-module Ey
-  module Core
-    module TestHelpers
-      module AccountHelpers
-        def create_account(options={})
-          client = options[:client]
-          creator = options[:creator] || client || create_client
-
-          attributes = options[:account] || {}
-          attributes[:type] ||= "beta" # get around awsm billing requirements for tests
-          attributes[:name] ||= SecureRandom.hex(6)
-
-          if client
-            attributes[:owner] ||= begin
-                                     client.users.current
-                                   rescue Ey::Core::Response::NotFound
-                                   end
-          end
-          attributes[:owner] ||= create_user(client: client)
-
-          created_account = (client || creator).accounts.create!(attributes)
-
-          if client
-            client.accounts.get!(created_account.identity)
-          else
-            created_account
-          end
-        end
-
-        def create_user(options={})
-          client = options[:client]
-          creator = options[:creator] || client || create_client
-
-          attributes = options[:user] || {}
-          attributes[:name] ||= Faker::Name.name
-          attributes[:email] ||= Faker::Internet.email
-
-          created_user = creator.users.create!(attributes)
-
-          if client
-            client.users.get!(created_user.identity)
-          else
-            created_user
-          end
-        end
-
-        def create_provider(options={})
-          account = options[:account] || create_account(options)
-
-          attributes = options[:provider] || {}
-          attributes[:type] ||= :aws
-          attributes[:provisioned_id] ||= SecureRandom.hex(8)
-          attributes[:credentials] ||= case attributes[:type]
-                                       when :aws then
-                                         {
-                                           :instance_aws_secret_id  => SecureRandom.hex(6),
-                                           :instance_aws_secret_key => SecureRandom.hex(6),
-                                           :aws_secret_id           => SecureRandom.hex(6),
-                                           :aws_secret_key          => SecureRandom.hex(6),
-                                           :aws_login               => Faker::Internet.email,
-                                           :aws_pass                => SecureRandom.hex(6),
-                                         }
-                                       when :azure then
-                                         {
-                                         }
-                                       end
-
-          account.providers.create!(attributes).resource!
-        end
-      end
-    end
-  end
-end
+module Ey
+  module Core
+    module TestHelpers
+      module AccountHelpers
+        def create_account(options={})
+          client = options[:client]
+          creator = options[:creator] || client || create_client
+
+          attributes = options[:account] || {}
+          attributes[:type] ||= "beta" # get around awsm billing requirements for tests
+          attributes[:name] ||= SecureRandom.hex(6)
+
+          if client
+            attributes[:owner] ||= begin
+                                     client.users.current
+                                   rescue Ey::Core::Response::NotFound
+                                   end
+          end
+          attributes[:owner] ||= create_user(client: client)
+
+          created_account = (client || creator).accounts.create!(attributes)
+
+          if client
+            client.accounts.get!(created_account.identity)
+          else
+            created_account
+          end
+        end
+
+        def create_user(options={})
+          client = options[:client]
+          creator = options[:creator] || client || create_client
+
+          attributes = options[:user] || {}
+          attributes[:name] ||= Faker::Name.name
+          attributes[:email] ||= Faker::Internet.email
+
+          created_user = creator.users.create!(attributes)
+
+          if client
+            client.users.get!(created_user.identity)
+          else
+            created_user
+          end
+        end
+
+        def create_provider(options={})
+          account = options[:account] || create_account(options)
+
+          attributes = options[:provider] || {}
+          attributes[:type] ||= :aws
+          attributes[:provisioned_id] ||= SecureRandom.hex(8)
+          attributes[:credentials] ||= case attributes[:type]
+                                       when :aws then
+                                         {
+                                           :instance_aws_secret_id  => SecureRandom.hex(6),
+                                           :instance_aws_secret_key => SecureRandom.hex(6),
+                                           :aws_secret_id           => SecureRandom.hex(6),
+                                           :aws_secret_key          => SecureRandom.hex(6),
+                                           :aws_login               => Faker::Internet.email,
+                                           :aws_pass                => SecureRandom.hex(6),
+                                         }
+                                       when :azure then
+                                         {
+                                         }
+                                       end
+
+          account.providers.create!(attributes).resource!
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/test_helpers/alert_helpers.rb

@@ -1,16 +1,16 @@
-module Ey
-  module Core
-    module TestHelpers
-      module AlertHelpers
-        def create_legacy_alert(client, attributes={})
-          attributes = Cistern::Hash.stringify_keys(attributes)
-
-          if server = attributes.delete("server")
-            attributes["server"] = client.url_for("/servers/#{server.id}")
-          end
-          client.data[:legacy_alerts][attributes["id"]] = attributes
-        end
-      end
-    end
-  end
-end
+module Ey
+  module Core
+    module TestHelpers
+      module AlertHelpers
+        def create_legacy_alert(client, attributes={})
+          attributes = Cistern::Hash.stringify_keys(attributes)
+
+          if server = attributes.delete("server")
+            attributes["server"] = client.url_for("/servers/#{server.id}")
+          end
+          client.data[:legacy_alerts][attributes["id"]] = attributes
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/test_helpers/client_helpers.rb

@@ -1,40 +1,40 @@
-module Ey
-  module Core
-    module TestHelpers
-      module ClientHelpers
-        def create_client(attributes={})
-          token = if (user = attributes.delete(:user)) && Ey::Core::Client.mocking?
-                    core = Ey::Core::Client::Mock.data.values.find { |c| c[:users][user.identity] }
-                    core[:users][user.identity]["token"]
-                  end
-          token ||= begin
-                      token_dotfile = YAML.load_file(File.expand_path("/../../../.token"), __FILE__) rescue {}
-                      ENV["CORE_TOKEN"] || token_dotfile[ENV["CORE_URL"]] || "a4bf6558da8c1051536d1596b8931ebd346aff0b"
-                    end
-
-          merged_attributes = attributes.merge(token: token, cache: true)
-          merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
-
-          Ey::Core::Client.new(merged_attributes)
-        end
-
-        def create_server_client(server, attributes={})
-          unless core = Ey::Core::Client::Mock.data.values.find { |data| data[:servers][server.identity] }
-            raise "Failed to find server in mock data: #{server}"
-          end
-
-          token = core[:servers][server.identity]["token"]
-
-          merged_attributes = attributes.merge(token: token, cache: true)
-          merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
-
-          Ey::Core::Client.new(merged_attributes)
-        end
-
-        def create_unauthenticated_client
-          Ey::Core::Client.new(token: nil)
-        end
-      end
-    end
-  end
-end
+module Ey
+  module Core
+    module TestHelpers
+      module ClientHelpers
+        def create_client(attributes={})
+          token = if (user = attributes.delete(:user)) && Ey::Core::Client.mocking?
+                    core = Ey::Core::Client::Mock.data.values.find { |c| c[:users][user.identity] }
+                    core[:users][user.identity]["token"]
+                  end
+          token ||= begin
+                      token_dotfile = YAML.load_file(File.expand_path("/../../../.token"), __FILE__) rescue {}
+                      ENV["CORE_TOKEN"] || token_dotfile[ENV["CORE_URL"]] || "a4bf6558da8c1051536d1596b8931ebd346aff0b"
+                    end
+
+          merged_attributes = attributes.merge(token: token, cache: true)
+          merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
+
+          Ey::Core::Client.new(merged_attributes)
+        end
+
+        def create_server_client(server, attributes={})
+          unless core = Ey::Core::Client::Mock.data.values.find { |data| data[:servers][server.identity] }
+            raise "Failed to find server in mock data: #{server}"
+          end
+
+          token = core[:servers][server.identity]["token"]
+
+          merged_attributes = attributes.merge(token: token, cache: true)
+          merged_attributes.merge!(logger: Logger.new(STDOUT)) if ENV['VERBOSE']
+
+          Ey::Core::Client.new(merged_attributes)
+        end
+
+        def create_unauthenticated_client
+          Ey::Core::Client.new(token: nil)
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/test_helpers/cucumber.rb

@@ -1,3 +1,3 @@
-require 'ey-core/test_helpers'
-
-World(Ey::Core::TestHelpers)
+require 'ey-core/test_helpers'
+
+World(Ey::Core::TestHelpers)