ey-core 3.0.0

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def update_membership(params={})
+      id = params.delete("id")
+      request(
+        :method => :put,
+        :path   => "/memberships/#{id}",
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def update_membership(params={})
+      resource_id = resource_identity(params)
+
+      membership = self.find(:memberships, resource_id)
+      if params["membership"] && params["membership"]["accepted"]
+        self.find(:accounts, resource_identity(membership["account"]))[:account_users] << resource_identity(membership["user"])
+      end
+
+      #NOTE: doesn't currently support updating role
+      response(
+        :body   => {"membership" => membership},
+        :status => 200,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def update_server(params={})
+      request(
+        :method => :put,
+        :path   => "/servers/#{params.fetch("id")}",
+        :body   => {"server" => params.fetch("server")},
+      )
+    end
+  end
+
+  class Mock
+    def update_server(params={})
+      server = find(:servers, params.fetch("id"))
+
+      server_params = Cistern::Hash.slice(
+        Cistern::Hash.stringify_keys(params["server"]),
+        "provisioned_at", "deprovisioned_at", "disappeared_at"
+      )
+
+      server.merge!("state" => params["server"]["status"]) if params["server"]["status"]
+      server.merge!(server_params.merge("updated_at" => Time.now))
+
+      response(
+        :body => { "server" => server },
+      )
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+class Ey::Core::Client
+  class Real
+    def update_ssl_certificate(params={})
+      id = params.delete("id")
+
+      request(
+        :method => :put,
+        :path   => "/ssl_certificates/#{id}",
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def update_ssl_certificate(params={})
+      ssl_certificate = self.find(:ssl_certificates, resource_identity(params))
+
+      ssl_certificate.merge!(params["ssl_certificate"])
+
+      response(
+        :body => {"ssl_certificate" => ssl_certificate}
+      )
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+class Ey::Core::Client
+  class Real
+    def update_untracked_server(params={})
+      request(
+        :method => :put,
+        :path   => "/untracked-servers/#{params.delete("id")}",
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def update_untracked_server(params={})
+      identity = resource_identity(params) || require_parameters(params["untracked_server"], "id")
+      server  = find(:untracked_servers, identity)
+
+      update_params = Cistern::Hash.slice(params["untracked_server"], "provisioner_id", "location", "state")
+
+      response(
+        :body => { "untracked_server" => server.merge!(update_params) },
+      )
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+class Ey::Core::Client
+  class Real
+    def upload_file(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+
+      mime_type  = params["mime_type"]
+      upload_url = params["upload_url"]
+
+      if string = params["body"]
+        request(
+          :method  => :put,
+          :headers => {"Content-Type" => mime_type},
+          :url     => upload_url,
+          :body    => string,
+        )
+      else
+        request(
+          :method  => :put,
+          :headers => {"Content-Type" => "multipart/form-data"},
+          :url     => upload_url,
+          :body    => Faraday::UploadIO.new(params.fetch("file"), mime_type),
+        )
+      end
+    end
+  end # Real
+
+  class Mock
+    def upload_file(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      upload_url = params["upload_url"]
+
+      temp_file = Tempfile.new("ey-core")
+      temp_file.write(params["body"] || File.read(params.fetch("file")))
+      temp_file.close
+
+      self.data[:temp_files][upload_url] = temp_file.path
+
+      response(
+        :body   => "",
+        :status => 200,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

data/lib/ey-core/response.rb

@@ -0,0 +1,55 @@
+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
+  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

@@ -0,0 +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

data/lib/ey-core/subscribable.rb

@@ -0,0 +1,49 @@
+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
+
+    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}")
+
+      deferred = client.subscribe(subscription) do |message|
+        block.call(JSON.load(message))
+      end
+
+      deferred.callback do
+        block.call({"meta" => true, "created_at" => Time.now,"message" => "successfully subscribed"})
+      end
+
+      deferred.errback do |error|
+        block.call({"meta" => true, "created_at" => Time.now, "message" => "subscription failed: #{error.inspect}"})
+        EM.stop_event_loop
+      end
+
+      EventMachine::PeriodicTimer.new(5) do
+        if resource.reload.ready?
+          block.call({"meta" => true, "created_at" => Time.now, "message" => "#{resource} is finished"})
+          EM.stop_event_loop
+        end
+      end
+    end
+  end
+end

data/lib/ey-core/token_authentication.rb

@@ -0,0 +1,13 @@
+class Ey::Core::TokenAuthentication < Faraday::Response::Middleware
+  attr_reader :token
+
+  def initialize(app, token)
+    super(app)
+    @token = token
+  end
+
+  def call(env)
+    env[:request_headers]["X-EY-TOKEN"] = token
+    super
+  end
+end

data/lib/ey-core/version.rb

@@ -0,0 +1,5 @@
+module Ey
+  module Core
+    VERSION = "3.0.0"
+  end
+end

data/spec/account_trial_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "account_trial" do
+  let!(:client) { create_client }
+
+  context "with an account", :mock_only do
+    let!(:account) { create_account(client: client) }
+
+    it "has trial data" do
+      trial = account.account_trial
+
+      expect(trial.duration).to eq(500)
+      expect(trial.used).to     eq(30)
+      expect(trial.account).to  eq(account)
+    end
+  end
+end

data/spec/accounts_referrals_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'account_referrals' do
+  let(:client) { create_client }
+  let!(:referrer) { create_account(client: client) }
+
+  it 'shows referrals for an account', :mock_only do
+    referral = create_account_referral(client, referrer: referrer)
+
+    expect(referrer.referrals.all).to contain_exactly(referral)
+  end
+
+  it 'shows all account referrals', :mock_only do
+    referral1 = create_account_referral(client)
+    referral2 = create_account_referral(client)
+    account_referrals = client.account_referrals.all
+
+    expect(account_referrals.map(&:identity)).to contain_exactly(referral1.id, referral2.id)
+  end
+end

data/spec/accounts_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe 'accounts' do
+
+  let!(:client) { create_client }
+
+  context "with a user" do
+    let!(:user) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+    let(:user_client) { create_client }
+
+    it "should create an account" do
+      name = Faker::Name.first_name
+
+      account = client.accounts.create!(owner: user, name: name)
+
+      # signup_via is foyer only
+      # account = client.accounts.create!(owner: user, name: name, signup_via: "deis")
+      # expect(account.signup_via).to eq("deis")
+
+      expect(account.name).to eq(name)
+      expect(account.support_plan).to eq("standard")
+
+      users = account.users.all
+      expect(users.size).to eq(1)
+      expect(users.first).to eq(user)
+    end
+
+    it "should create an account by name_prefix" do
+      account1 = client.accounts.create!(owner: user, name_prefix: "azure")
+      account2 = client.accounts.create!(owner: user, name_prefix: "azure")
+
+      expect(account1.name).to match(/azure/)
+      expect(account2.name).to match(/azure/)
+    end
+
+    it "should cancel an account" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      c = account.cancel!(:requested_by => user)
+      expect(c.kind).to eq "self"
+      account_refetched = client.accounts.get(account.id)
+      expect(account_refetched.cancelled_at).not_to be_nil
+      expect(account_refetched.cancellation).to eq c
+    end
+
+    it "should get an account" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+
+      expect(client.accounts.get(account.id)).to eq(account)
+    end
+
+    it "should have a nil cancellation" do
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      expect(account.cancellation).to be_nil
+    end
+
+    it "should get all accounts for a user" do
+      account         = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      another_user    = client.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      client.accounts.create!(owner: another_user, name: Faker::Name.first_name)
+
+      expect(user.accounts.all).to match_array([account])
+    end
+
+    context "a second user" do
+      let!(:user2) { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+
+      it "should not be associated with unrelated users" do
+        name = Faker::Name.first_name
+
+        account = client.accounts.create!(owner: user2, name: name)
+
+        users = account.users.all
+
+        expect(users.size).to eq(1)
+        expect(users.first).to eq(user2)
+      end
+    end
+
+    it "should search by legacy_id", mock_only: true do
+      legacy_id = Cistern::Mock.random_numbers(6)
+
+      account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+      client.data[:accounts][account.id]["legacy_id"] = legacy_id
+
+      expect(client.accounts.first(legacy_id: legacy_id)).to eq(account)
+    end
+
+    context "owners" do
+      it "should contain the owner user" do
+        account = client.accounts.create!(owner: user, name: Faker::Name.first_name)
+
+        owner = account.owners.all.first
+        expect(owner.id).to eq(user.id)
+      end
+    end
+  end
+
+  context "with two clients pointed to different clouds", :mock_only do
+    let!(:client_1) { create_client(url: 'http://client-1.example.com') }
+    let!(:client_2) { create_client(url: 'http://client-2.example.com') }
+
+    it "should not about each other's accounts" do
+      owner_1   = client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      account_1 = client_1.accounts.create!(owner: owner_1, name: Faker::Name.first_name)
+
+      owner_2   = client_2.users.create!(name: Faker::Name.name, email: Faker::Internet.email)
+      account_2 = client_2.accounts.create!(owner: owner_2, name: Faker::Name.first_name)
+
+      expect(client_1.accounts.get(account_2.id)).to be_nil
+      expect(client_2.accounts.get(account_1.id)).to be_nil
+    end
+  end
+end