ey-core 3.0.0

data/spec/metadata_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'as a client' do
+  let!(:client) { create_client }
+
+  it "should display metadata information" do
+    environment = Ey::Core::Client.mocking? ? "mock" : "development"
+
+    expect(client.metadata.environment).to eq(environment)
+  end
+end

data/spec/plan_usage_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe "plan_usage", :mock_only do
+  let!(:client)  { create_client }
+  let!(:account) { create_account(client: client, account: { owner: create_user(client: client)}) }
+
+  before(:each) do
+    Timecop.freeze(Time.parse("2014-06-04 09:13:39 -0800"))
+
+    now             = Time.now
+    billing_month   = now.strftime("%Y-%m")
+    month_beginning = DateTime.new(now.year, now.month, 1)
+    end_of_month    = DateTime.new(now.year, (now.month + 1) % 12, 1, 23, 59, 59) - 1
+
+    client.data[:plan_usages][account.id].merge!(
+    {
+      "2014-05" => [
+        {
+          "start_at"     => "2014-05-01T00:00:00+00:00",
+          "end_at"       => "2014-05-31T23:59:59+00:00",
+          "type"         => "classic-00",
+          "support"      => "premium",
+          "server_limit" => nil,
+          "flavor_limit" => nil,
+        },
+      ],
+      billing_month => [
+        {
+          "start_at"     => month_beginning.iso8601,
+          "end_at"       => end_of_month.iso8601, # still valid
+          "type"         => "correct-type",
+          "support"      => "premium",
+          "server_limit" => nil,
+          "flavor_limit" => nil,
+        },
+      ],
+    })
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    plan_usages = client.plan_usages.all(account_id: account.id, billing_month: "2014-05")
+
+    expect(plan_usages.size).to eq(1)
+
+    plan_usage = plan_usages.first
+
+    expect(plan_usage.start_at).not_to be_nil
+    expect(plan_usage.end_at).not_to be_nil
+
+    expect(plan_usage.type).to eq("classic-00")
+    expect(plan_usage.support).to eq("premium")
+
+    expect(plan_usage.server_limit).to be_nil
+    expect(plan_usage.flavor_limit).to be_nil
+  end
+
+  it "defaults to the current billing_month" do
+    plan_usages = client.plan_usages.all(account_id: account.id)
+
+    expect(plan_usages.size).to eq(1)
+
+    plan_usage = plan_usages.first
+    expect(plan_usage.type).to eq("correct-type")
+  end
+end

data/spec/provider_locations_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'provider locations' do
+  context "with a hmac client" do
+    let!(:client)   { create_client }
+    let!(:account)  { create_account(client: client) }
+    let!(:provider) { create_provider(account: account) }
+
+    let!(:provider_location) do
+      if Ey::Core::Client.mocking?
+        create_provider_location(client,
+                                 :location_name => "Eastern United States",
+                                 :location_id   => "us-east-1",
+                                 :provider      => provider,
+                                 :limits        => {"servers" => 20, "addresses" => 5}
+                                )
+      else
+        provider.provider_locations.first
+      end
+    end
+
+    before do
+    end
+
+    it "should find the provider location" do
+      location = client.provider_locations.get(provider_location.id)
+
+      expect(location.id).to eq(provider_location.id)
+      expect(location.location_name).to eq(provider_location.location_name)
+      expect(location.location_id).to eq(provider_location.location_id)
+      expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
+      expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
+    end
+
+    context "with a provider" do
+      let!(:another_provider) { create_provider(client: client, account: account) }
+      let!(:another_location) do
+        if Ey::Core::Client.mocking?
+          create_provider_location(client,
+                                   :provider      => another_provider,
+                                   :location_name => "Western United States",
+                                   :location_id   => "us-west-1",
+                                   :limits        => {"servers" => 20, "addresses" => 5})
+        else
+          provider.provider_locations.last
+        end
+      end
+
+      it "should list provider locations" do
+        locations = provider.provider_locations.all
+
+        expect(locations.size).to be > 0
+
+        location = locations.first(location_id: provider_location.location_id)
+
+        expect(location.id).to eq(provider_location.id)
+        expect(location.location_name).to eq(provider_location.location_name)
+        expect(location.location_id).to eq(provider_location.location_id)
+        expect(location.limits["servers"]).to eq(provider_location.limits["servers"])
+        expect(location.limits["addresses"]).to eq(provider_location.limits["addresses"])
+      end
+    end
+  end
+end

data/spec/providers_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe 'providers' do
+  context "with a hmac client" do
+    let!(:client)  { create_client }
+    let!(:account) { create_account(client: client) }
+
+    ["azure", "aws"].each do |provider|
+      it "should have possible #{provider} locations without a provider type" do
+        locations = client.provider.possible_locations(provider)
+        expect(locations).to be_a(Array)
+        expect(locations).not_to be_empty
+      end
+    end
+
+    context "with an account" do
+      ["aws", "azure"].each do |type|
+        it "should create a #{type} provider" do
+          provisioned_id = SecureRandom.hex(8)
+          provider = account.providers.create!(type: type, provisioned_id: provisioned_id, credentials: {}).resource!
+
+          expect(provider.account).to        eq(account)
+          expect(provider.type).to           eq(type)
+          expect(provider.provisioned_id).to eq(provisioned_id)
+        end
+
+        context "with a #{type} provider" do
+          let!(:provider) { account.providers.create!(type: type, provisioned_id: SecureRandom.hex(8), credentials: {}).resource! }
+
+          it "should get an provider" do
+            expect(account.providers.get(provider.id)).to eq(provider)
+          end
+
+          it "should have possible provider locations" do
+            expect(provider.possible_locations).to be_a(Array)
+            expect(provider.possible_locations).not_to be_empty
+          end
+
+          it "should get providers" do
+            another_account = create_account(client: client)
+            create_provider(account: another_account)
+
+            account_providers = account.providers.all
+
+            expect(account_providers.size).to eq(1)
+            expect(account_providers.first).to eq(provider)
+          end
+
+          it "should destroy the provider" do
+            expect(provider.destroy.ready!).to be_successful
+            expect(provider.reload.cancelled_at).not_to be_nil
+          end
+
+          it "should discover locations for the #{type} provider", :mock_only do
+            provider.possible_locations.each do |location_id|
+              provider_location = nil
+              expect {
+                provider_location = provider.provider_locations.discover(location_id).resource!
+                expect(provider_location).to be_a(Ey::Core::Client::ProviderLocation)
+                expect(provider_location.location_id).to eq(location_id)
+              }.to change { provider.provider_locations.all.reload.count }
+            end
+          end
+        end
+      end
+    end
+
+    context "with two clients pointed to the same cloud", :mock_only do
+      let!(:client_1) { create_client(url: "http://client.example.com") }
+      let!(:owner)    { client_1.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+      let!(:client_1_account_1) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
+      let!(:client_1_account_2) { client_1.accounts.create!(owner: owner, name: Faker::Name.first_name)}
+
+      it "should not clobber other accounts' providers" do
+        # this just tests that the mock behaves reasonably
+        client_1_account_1.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(0)
+
+        client_1_account_2.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(1)
+
+        client_2 = create_client(url: "http://client.example.com")
+
+        client_2_account_1 = client_2.accounts.get(client_1_account_1.id)
+        expect(client_2_account_1).not_to be_nil
+        client_2_account_2 = client_2.accounts.get(client_1_account_2.id)
+        expect(client_2_account_2).not_to be_nil
+
+        client_2_account_2.providers.create!(type: "aws").ready!
+
+        expect(client_1_account_1.providers.all.count).to eq(1)
+        expect(client_2_account_1.providers.all.count).to eq(1)
+        expect(client_1_account_2.providers.all.count).to eq(2)
+        expect(client_2_account_2.providers.all.count).to eq(2)
+
+        expect(client_1.providers.count).to eq(3)
+        expect(client_2.providers.count).to eq(3)
+      end
+    end
+  end
+end

data/spec/requests/upload_file_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "#upload_file" do
+  it "should upload a multipart_file", :real_only do
+    requests = []
+    canary = lambda { |env| requests << Rack::Request.new(env); [200, {}, []] }
+    client = Ey::Core::Client.new(adapter: [:rack, canary], token: "blah")
+
+    begin
+      file = Tempfile.new('foo')
+      file.write("bar")
+      file.close
+
+      client.upload_file(:file => file.path)
+    ensure
+      file.close
+      file.unlink   # deletes the temp file
+    end
+
+    request = requests.first
+
+    expect(request.content_type).to eq("multipart/form-data")
+    expect(request.body.read).to eq("bar")
+  end
+end

data/spec/requests_spec.rb

@@ -0,0 +1,23 @@
+
+require 'spec_helper'
+
+RSpec.describe Ey::Core::Client do
+  let!(:client)   { create_client }
+  let!(:account)  { create_account }
+  let!(:user)     { create_user }
+
+  context "with a request" do
+    let!(:request) { account.providers.create!(type: "aws") }
+
+    it "should list unfinished requests" do
+      expect(client.requests.all(finished_at: nil)).to contain_exactly(request)
+    end
+
+    it "request should finish after polling a number of times == Mock.delay" do
+      Ey::Core::Client::Mock.delay = 3
+      expect(client.requests.get(request.id).finished_at).to be_nil
+      expect(client.requests.get(request.id).finished_at).to be_nil
+      expect(client.requests.get(request.id).finished_at).to_not be_nil
+    end
+  end
+end

data/spec/reset_password_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "reset_password" do
+  context "with an HMAC client" do
+    let!(:client) { create_client }
+
+    it "should create a password reset request" do
+      email = create_user.email
+
+      password_reset = client.create_password_reset(email: email, redirect_uri: "http://example.com").body["password_reset"]
+
+      expect(password_reset).to eq("sent" => true)
+    end
+
+    it "should reset a users password", :mock_only do
+      password_reset = client.reset_password(reset_token: SecureRandom.hex(6), password: SecureRandom.hex(6)).body["password_reset"]
+
+      expect(password_reset).to eq("accepted" => true)
+    end
+  end
+end
+

data/spec/server_events_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'servers' do
+  let!(:client)   { create_client }
+  let!(:user)     { client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+  let!(:account)  { client.accounts.create!(owner: user, name: Faker::Name.name) }
+  let!(:provider) { account.providers.create!(type: "aws").resource! }
+
+  context "with a server", :mock_only do
+    let!(:environment) { create_environment(account: account, name: Faker::Name.name) }
+
+    before(:each) do
+      pending "adding servers to environments is not yet implemented"
+      another_server = create_server(client,
+                                     :environment => environment,
+                                     :provider => provider,
+                                     :provisioned_id => "i-a1000fce",
+                                     :state => "running")
+
+      create_server_event(client,
+                          :type   => "member-failed",
+                          :server => another_server)
+    end
+
+    it "should list server events" do
+      server = create_server(environment: environment)
+      event  = create_server_event(client, type: "memer-failed", server: server)
+      expect(server.events.to_a).to eq([event])
+    end
+  end
+end

data/spec/server_usage_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe "server_usage", :mock_only do
+  let!(:client)      { create_client }
+  let!(:account)     { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:environment) { create_environment(account: account, name: SecureRandom.hex(10)) }
+
+  before(:each) do
+    now             = Time.now
+    billing_month   = now.strftime("%Y-%m")
+    month_beginning = DateTime.new(now.year, now.month, 1)
+
+    client.find(:server_usages, account.id).merge!(
+      "2014-05" => [
+        {
+          "start_at"    => "2014-05-01T00:00:00+00:00",
+          "end_at"      => "2014-05-31T23:59:59+00:00",
+          "report_time" => Time.now.iso8601,
+          "flavor"      => "m1.large",
+          "dedicated"   => false,
+          "location"    => "us-east-1d",
+          "environment" => "https://api.engineyard.com/environments/#{environment.id}",
+          "provider"    => "https://api.engineyard.com/providers/#{provider.id}",
+        },
+      ],
+      billing_month => [
+        {
+          "start_at"    => month_beginning.iso8601,
+          "end_at"      => nil, # still running
+          "report_time" => now.iso8601,
+          "flavor"      => "m1.large",
+          "dedicated"   => false,
+          "location"    => "correct-location",
+          "environment" => "https://api.engineyard.com/environments/#{environment.id}",
+          "provider"    => "https://api.engineyard.com/providers/#{provider.id}",
+        },
+      ],
+    )
+  end
+
+  it "can fetch usage for an account and billing_month" do
+    server_usages = client.server_usages.all(account_id: account.id, billing_month: "2014-05")
+
+    expect(server_usages.size).to eq(1)
+
+    server_usage = server_usages.first
+
+    expect(server_usage.start_at).not_to be_nil
+    expect(server_usage.end_at).not_to be_nil
+    expect(server_usage.report_time).not_to be_nil
+
+    expect(server_usage.flavor).to   eq("m1.large")
+    expect(server_usage.location).to eq("us-east-1d")
+
+    expect(server_usage.dedicated).to be false
+
+    expect(server_usage.environment).to eq(environment)
+    expect(server_usage.provider).to    eq(provider)
+  end
+
+  it "defaults to the current billing_month" do
+    server_usages = client.server_usages.all(account_id: account.id)
+
+    expect(server_usages.size).to eq(1)
+
+    server_usage = server_usages.first
+    expect(server_usage.location).to eq("correct-location")
+  end
+end

data/spec/servers_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'servers' do
+  let!(:client)      { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:application) { create_application(account: account) }
+  context "with a solo environment" do
+
+    let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name) }
+    let!(:server)      { environment.servers.first }
+
+    it "has an association with the environment" do
+      expect(server.environment).to eq(environment)
+    end
+
+    it "reboots" do
+      reboot_request = server.reboot
+      reboot_request.ready!
+      expect(reboot_request.successful).to be true
+    end
+
+    it "does not destroy" do
+      expect {
+        server.destroy
+      }.to raise_error(Ey::Core::Client::NotPermitted)
+    end
+
+    it "lists servers by environment" do
+      expect(environment.servers).to contain_exactly(server)
+    end
+
+    it "searches for servers by role" do
+      expect {
+        environment.servers.all(role: "solo").to contain_exactly(server)
+      }
+    end
+  end
+
+  context "with multiple servers" do
+    let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name, configuration: {"type" => "cluster"}) }
+    let!(:server)      { environment.servers.first }
+
+    it "destroys" do
+      expect {
+        server.destroy.ready!
+      }.to change { server.reload.deleted_at }.from(nil)
+    end
+
+    it "searches for servers by role" do
+      expect(environment.servers.first(role: "app_master")).to be
+      expect(environment.servers.first(role: "app")).to be
+      expect(environment.servers.first(role: "db_master")).to be
+    end
+  end
+end